Merge pull request #422 from salesforcecli/wr/sfEnvVars

fix: use SF prefixed env vars, add UTs

Author: iowillhoit

src/commands/info/releasenotes/display.ts

@@ -23,9 +23,6 @@ import { parseReleaseNotes } from '../../../shared/parseReleaseNotes';
 // Initialize Messages with the current plugin directory
 Messages.importMessagesDirectory(__dirname);
 
-const HIDE_NOTES = 'SFDX_HIDE_RELEASE_NOTES';
-const HIDE_FOOTER = 'SFDX_HIDE_RELEASE_NOTES_FOOTER';
-
 const helpers = ['stable', 'stable-rc', 'latest', 'latest-rc', 'rc'];
 
 // Load the specific messages for this file. Messages from @salesforce/command, @salesforce/core,
@@ -53,13 +50,14 @@ export default class Display extends SfCommand<DisplayOutput | undefined> {
   };
 
   public async run(): Promise<DisplayOutput | undefined> {
+    const HIDE_NOTES = this.config.bin === 'sf' ? 'SF_HIDE_RELEASE_NOTES' : 'SFDX_HIDE_RELEASE_NOTES';
+    const HIDE_FOOTER = this.config.bin === 'sf' ? 'SF_HIDE_RELEASE_NOTES_FOOTER' : 'SFDX_HIDE_RELEASE_NOTES_FOOTER';
+
     const logger = Logger.childFromRoot(this.constructor.name);
     const { flags } = await this.parse(Display);
     const env = new Env();
 
-    const isHook = !!flags.hook;
-
-    if (env.getBoolean(HIDE_NOTES) && isHook) {
+    if (env.getBoolean(HIDE_NOTES) && flags.hook) {
       // We don't ever want to exit the process for info:releasenotes:display (whatsnew)
       // In most cases we will log a message, but here we only trace log in case someone using stdout of the update command
       logger.trace(`release notes disabled via env var: ${HIDE_NOTES}`);
@@ -100,7 +98,7 @@ export default class Display extends SfCommand<DisplayOutput | undefined> {
         this.log(marked.parser(tokens));
       }
 
-      if (isHook) {
+      if (flags.hook) {
         if (env.getBoolean(HIDE_FOOTER)) {
           await Lifecycle.getInstance().emitTelemetry({ eventName: 'FOOTER_HIDDEN' });
         } else {
@@ -109,7 +107,7 @@ export default class Display extends SfCommand<DisplayOutput | undefined> {
         }
       }
     } catch (err) {
-      if (isHook) {
+      if (flags.hook) {
         // Do not throw error if --hook is passed, just warn so we don't exit any processes.
         // --hook is passed in the post install/update scripts
         const { message, stack, name } = err as Error;

test/commands/info/releasenotes/display.test.ts

@@ -25,7 +25,7 @@ import Display from '../../../../src/commands/info/releasenotes/display';
 // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
 chaiUse(SinonChai);
 
-describe('info:releasenotes:display', () => {
+describe('sfdx info:releasenotes:display', () => {
   const sandbox = Sinon.createSandbox();
 
   let mockInfoConfig: getInfoConfig.InfoConfig;
@@ -264,3 +264,242 @@ describe('info:releasenotes:display', () => {
     expect(json).to.deep.equal(expected);
   });
 });
+describe('sf info:releasenotes:display', () => {
+  const sandbox = Sinon.createSandbox();
+
+  let mockInfoConfig: getInfoConfig.InfoConfig;
+  let getBooleanStub: sinon.SinonStub;
+  let uxLogStub: sinon.SinonStub;
+  let uxWarnStub: sinon.SinonStub;
+  let getInfoConfigStub: Sinon.SinonStub;
+  let getReleaseNotesStub: Sinon.SinonStub;
+  let getDistTagVersionStub: Sinon.SinonStub;
+  let parseReleaseNotesSpy: Sinon.SinonSpy;
+  let markedParserSpy: Sinon.SinonSpy;
+
+  const oclifConfigStub = fromStub(stubInterface<Config>(sandbox));
+
+  class TestDisplay extends Display {
+    public async runIt() {
+      await this.init();
+      return this.run();
+    }
+  }
+
+  const runDisplayCmd = async (params: string[]) => {
+    oclifConfigStub.bin = 'sf';
+
+    const cmd = new TestDisplay(params, oclifConfigStub);
+
+    uxLogStub = stubMethod(sandbox, SfCommand.prototype, 'log');
+    uxWarnStub = stubMethod(sandbox, SfCommand.prototype, 'warn');
+
+    return cmd.runIt();
+  };
+
+  beforeEach(() => {
+    mockInfoConfig = {
+      releasenotes: {
+        distTagUrl: 'https://registry.npmjs.org/-/package/sfdx-cli/dist-tags',
+        releaseNotesPath: 'https://github.com/forcedotcom/cli/tree/main/releasenotes/sfdx',
+        releaseNotesFilename: 'README.md',
+      },
+    };
+
+    oclifConfigStub.pjson.version = '3.3.3';
+    oclifConfigStub.root = '/root/path';
+
+    getBooleanStub = stubMethod(sandbox, Env.prototype, 'getBoolean');
+    getBooleanStub.withArgs('SF_HIDE_RELEASE_NOTES').returns(false);
+    getBooleanStub.withArgs('SF_HIDE_RELEASE_NOTES_FOOTER').returns(false);
+
+    getInfoConfigStub = stubMethod(sandbox, getInfoConfig, 'getInfoConfig').returns(mockInfoConfig);
+    getReleaseNotesStub = stubMethod(sandbox, getReleaseNotes, 'getReleaseNotes').returns('## Release notes for 3.3.3');
+    getDistTagVersionStub = stubMethod(sandbox, getDistTagVersion, 'getDistTagVersion').returns('1.2.3');
+    parseReleaseNotesSpy = spyMethod(sandbox, parseReleaseNotes, 'parseReleaseNotes');
+    markedParserSpy = spyMethod(sandbox, marked, 'parser');
+  });
+
+  afterEach(() => {
+    sandbox.restore();
+  });
+
+  it('allows you to suppress release notes output with env var', async () => {
+    // This env var is only honored when the --hook flag is passed.
+    // If someone is running the command directly, we show notes regardless.
+    getBooleanStub.withArgs('SF_HIDE_RELEASE_NOTES').returns(true);
+
+    const lifecycleStub = stubMethod(sandbox, Lifecycle.prototype, 'emitTelemetry');
+
+    await runDisplayCmd(['--hook']);
+
+    expect(lifecycleStub.calledOnce).to.equal(true);
+    expect(uxLogStub.called).to.be.false;
+    expect(uxWarnStub.called).to.be.false;
+  });
+
+  it('ignores hide release notes env var if running command directly (without --hook)', async () => {
+    getBooleanStub.withArgs('SF_HIDE_RELEASE_NOTES').returns(true);
+
+    await runDisplayCmd([]);
+
+    expect(uxLogStub.args[0][0]).to.contain('## Release notes for 3.3.3');
+  });
+
+  it('calls getInfoConfig with config root', async () => {
+    await runDisplayCmd([]);
+
+    expect(getInfoConfigStub.args[0][0]).to.equal('/root/path');
+  });
+
+  it('does not render emoji', async () => {
+    getReleaseNotesStub.returns('## 3.3.3 :tada:');
+
+    await runDisplayCmd([]);
+
+    expect(uxLogStub.args[0][0]).to.contain('## 3.3.3 :tada:');
+  });
+
+  it('throws an error if info config lookup fails', async () => {
+    getInfoConfigStub.throws(new Error('info config error'));
+
+    try {
+      await shouldThrow(runDisplayCmd([]));
+    } catch (err) {
+      expect((err as Error).message).to.contain('info config error');
+    }
+  });
+
+  it('does not call getDistTagVersion if helper is not passed', async () => {
+    await runDisplayCmd([]);
+
+    expect(getDistTagVersionStub.called).to.be.false;
+  });
+
+  it('calls getDistTagVersion with correct are if helpers are used', async () => {
+    await runDisplayCmd(['-v', 'latest-rc', '--hook']);
+
+    expect(getDistTagVersionStub.args[0]).to.deep.equal([mockInfoConfig.releasenotes.distTagUrl, 'latest-rc']);
+  });
+
+  it('throws an error if dist tag lookup fails', async () => {
+    getDistTagVersionStub.throws(new Error('dist tag error'));
+
+    try {
+      await shouldThrow(runDisplayCmd(['-v', 'latest-rc']));
+    } catch (err) {
+      expect((err as Error).message).to.contain('dist tag error');
+    }
+  });
+
+  it('calls getReleaseNotes with version returned from getDistTagVersion', async () => {
+    await runDisplayCmd(['-v', 'latest-rc', '--hook']);
+
+    const expected = [
+      mockInfoConfig.releasenotes.releaseNotesPath,
+      mockInfoConfig.releasenotes.releaseNotesFilename,
+      '1.2.3',
+    ];
+
+    expect(getReleaseNotesStub.args[0]).to.deep.equal(expected);
+  });
+
+  it('logs logs a header with cli bin', async () => {
+    await runDisplayCmd([]);
+
+    expect(uxLogStub.args[0][0]).to.contain("# Release notes for 'sf':");
+  });
+
+  it('calls getReleaseNotes with passed version', async () => {
+    await runDisplayCmd(['-v', '4.5.6', '--hook']);
+
+    expect(getReleaseNotesStub.args[0][2]).to.equal('4.5.6');
+  });
+
+  it('calls getReleaseNotes with installed version if no arg is passed', async () => {
+    await runDisplayCmd([]);
+
+    expect(getReleaseNotesStub.args[0][2]).to.equal('3.3.3');
+  });
+
+  it('throws an error if getReleaseNotes lookup fails', async () => {
+    getReleaseNotesStub.throws(new Error('release notes error'));
+
+    try {
+      await shouldThrow(runDisplayCmd([]));
+    } catch (err) {
+      expect((err as Error).message).to.contain('release notes error');
+    }
+  });
+
+  it('parseReleaseNotes is called with the correct args', async () => {
+    await runDisplayCmd([]);
+
+    expect(parseReleaseNotesSpy.args[0]).to.deep.equal([
+      '## Release notes for 3.3.3',
+      '3.3.3',
+      mockInfoConfig.releasenotes.releaseNotesPath,
+    ]);
+  });
+
+  it('parser is called with tokens', async () => {
+    await runDisplayCmd([]);
+
+    const tokens = parseReleaseNotesSpy.returnValues[0] as marked.Token;
+
+    expect(markedParserSpy.calledOnce).to.be.true;
+    expect(markedParserSpy.args[0][0]).to.deep.equal(tokens);
+  });
+
+  it('logs markdown on the command line', async () => {
+    await runDisplayCmd([]);
+
+    expect(uxLogStub.args[0][0]).to.contain('## Release notes for 3.3.3');
+  });
+
+  it('throws an error if parsing fails', async () => {
+    try {
+      await shouldThrow(runDisplayCmd(['-v', '4.5.6']));
+    } catch (err) {
+      expect((err as Error).message).to.contain(
+        `Didn't find version '4.5.6'. View release notes online at: ${mockInfoConfig.releasenotes.releaseNotesPath}`
+      );
+    }
+  });
+
+  it('does not throw an error if --hook is set', async () => {
+    getReleaseNotesStub.throws(new Error('release notes error'));
+    const lifecycleStub = stubMethod(sandbox, Lifecycle.prototype, 'emitTelemetry');
+
+    await runDisplayCmd(['--hook']);
+    expect(lifecycleStub.calledOnce).to.be.true;
+    expect(uxWarnStub.args[0][0]).to.contain('release notes error');
+  });
+
+  it('renders a footer if --hook is set', async () => {
+    await runDisplayCmd(['--hook']);
+
+    expect(uxLogStub.args[1][0]).to.contain('to manually view the current release notes');
+  });
+
+  it('hides footer if env var is set', async () => {
+    getBooleanStub.withArgs('SF_HIDE_RELEASE_NOTES_FOOTER').returns(true);
+
+    const lifecycleStub = stubMethod(sandbox, Lifecycle.prototype, 'emitTelemetry');
+
+    await runDisplayCmd(['--hook']);
+    expect(lifecycleStub.calledOnce).to.be.true;
+    expect(uxLogStub.args[2]).to.be.undefined;
+  });
+
+  it('supports json output', async () => {
+    const json = await runDisplayCmd(['--json']);
+
+    const expected = {
+      body: `# Release notes for 'sf':${os.EOL}## Release notes for 3.3.3`,
+      url: mockInfoConfig.releasenotes.releaseNotesPath,
+    };
+
+    expect(json).to.deep.equal(expected);
+  });
+});