semantic-release-vsce 5.5.10 → 5.6.0

package/README.md

@@ -9,11 +9,11 @@
 [![peerDependencies](https://david-dm.org/felipecrs/semantic-release-vsce/peer-status.svg)](https://david-dm.org/felipecrs/semantic-release-vsce?type=peer)
 [![semantic-release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg)](https://github.com/semantic-release/semantic-release)
 
-| Step      | Description                                                                                                                                                                                                          |
-| --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `verify`  | Verify the presence and the validity of the authentication (set via [environment variables](#environment-variables)) and the `package.json`                                                                          |
-| `prepare` | Generate the `.vsix` file using vsce, this can be be controlled by providing `packageVsix` in config. <br/> _Note: If the `OVSX_PAT` environment variable is set, this step will run even if not explicitly enabled_ |
-| `publish` | Publish the extension                                                                                                                                                                                                |
+| Step      | Description                                                                                                                                                 |
+| --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `verify`  | Verify the `package.json` and the validity of the personal access tokens against Visual Studio Marketplace and/or Open VSX Registry when publish is enabled |
+| `prepare` | Generate the `.vsix` file using `vsce` (can be be controlled by the [`packageVsix` config option](#packagevsix)                                             |
+| `publish` | Publish the extension to Visual Studio Marketplace and/or Open VSX Registry (learn more [here](#publishing))                                                |
 
 ## Install
 
@@ -60,7 +60,7 @@ The plugin can be configured in the [**semantic-release** configuration file](ht
 
 ### `packageVsix`
 
-Whether to package or not the extension `.vsix`, or where to place it. This controls if `vsce package` gets called or not, and what value will be used for `vsce package --out`.
+Whether to package or not the extension into a `.vsix` file, or where to place it. This controls if `vsce package` gets called or not, and what value will be used for `vsce package --out`.
 
 | Value              | Description                                                                                                  |
 | ------------------ | ------------------------------------------------------------------------------------------------------------ |
@@ -71,12 +71,12 @@ Whether to package or not the extension `.vsix`, or where to place it. This cont
 
 ### `publish`
 
-Whether to publish or not the extension to Visual Studio Marketplace or OpenVSX (if the `OVSX_PAT` environment variable is present). This controls if `vsce publish` or `ovsx publish` (if the `OVSX_PAT` environment variable is present) gets called or not.
+Whether to publish or not the extension to Visual Studio Marketplace and/or to Open VSX Registry. This controls if `vsce publish` or `ovsx publish` gets called or not. Learn more [here](#publishing).
 
-| Value            | Description                                                    |
-| ---------------- | -------------------------------------------------------------- |
-| `true` (default) | publishes the extension to Visual Studio Marketplace           |
-| `false`          | disables publishing the extension to Visual Studio Marketplace |
+| Value            | Description                                                                                |
+| ---------------- | ------------------------------------------------------------------------------------------ |
+| `true` (default) | publishes the extension to Visual Studio Marketplace and/or to Open VSX Registry           |
+| `false`          | disables publishing the extension to Visual Studio Marketplace and/or to Open VSX Registry |
 
 ### `publishPackagePath`
 
@@ -90,11 +90,13 @@ Which `.vsix` file (or files) to publish. This controls what value will be used
 
 ### Environment variables
 
+The following environment variables are supported by this plugin:
+
 | Variable      | Description                                                                                                                                                                                                                                                                                                     |
 | ------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `VSCE_PAT`    | **Required** (unless `publish` is set to `false`). The personal access token to publish the extension to Visual Studio Marketplace                                                                                                                                                                              |
+| `OVSX_PAT`    | _Optional_. The personal access token to push to Open VSX Registry                                                                                                                                                                                                                                              |
+| `VSCE_PAT`    | _Optional_. The personal access token to publish to Visual Studio Marketplace                                                                                                                                                                                                                                   |
 | `VSCE_TARGET` | _Optional_. The target to use when packaging or publishing the extension (used as `vsce package --target ${VSCE_TARGET}`). When set to `universal`, behave as if `VSCE_TARGET` was not set (i.e. build the universal/generic `vsix`). See [the platform-specific example](#platform-specific-on-github-actions) |
-| `OVSX_PAT`    | _Optional_. The personal access token to push to OpenVSX                                                                                                                                                                                                                                                        |
 
 ### Configuring `vsce`
 
@@ -104,7 +106,7 @@ You can set `vsce` options in the `package.json`, like:
 // package.json
 {
   "vsce": {
-    "baseImagesUrl": "https://my.custom/base/images/url"
+    "baseImagesUrl": "https://my.custom/base/images/url",
     "dependencies": true,
     "yarn": false
   }
@@ -113,19 +115,39 @@ You can set `vsce` options in the `package.json`, like:
 
 For more information, check the [`vsce` docs](https://github.com/microsoft/vscode-vsce#configuration).
 
-### Publishing to OpenVSX
+## Publishing
+
+This plugin can publish extensions to Visual Studio Marketplace and/or Open VSX Registry.
+
+You can enable or disable publishing with the [`publish`](#publish) config option.
+
+When publish is enabled (default), the plugin will publish to Visual Studio Marketplace if the `VSCE_PAT` environment variable is present, and/or to Open VSX Registry if the `OVSX_PAT` environment variable is present.
+
+For example, you may want to disable publishing if you only want to publish the `.vsix` file as a GitHub release asset.
+
+### Publishing to Visual Studio Marketplace
+
+Publishing extensions to Visual Studio Marketplace using this plugin is easy:
+
+1. Create your personal access token for Visual Studio Marketplace. Learn more [here](https://code.visualstudio.com/api/working-with-extensions/publishing-extension#get-a-personal-access-token).
+
+2. Configure the `VSCE_PAT` environment variable in your CI with the token that you created.
+
+3. Enjoy! The plugin will automatically detect the environment variable and it will publish to Visual Studio Marketplace, no additional configuration is needed.
+
+### Publishing to Open VSX Registry
 
-Publishing extensions to OpenVSX using this plugin is easy:
+Publishing extensions to Open VSX Registry using this plugin is easy:
 
-1. Get a valid personal access token with the correct privileges to the publisher namespace in OpenVSX. In order to get the personal access token, check this [page](https://github.com/eclipse/openvsx/wiki).
+1. Create your personal access token for Open VSX Registry. Learn more [here](https://github.com/eclipse/openvsx/wiki).
 
 2. Configure the `OVSX_PAT` environment variable in your CI with the token that you created.
 
-3. Enjoy! The plugin will automatically detect the environment variable and it will publish to OpenVSX, no additional configuration is needed.
+3. Enjoy! The plugin will automatically detect the environment variable and it will publish to Open VSX Registry, no additional configuration is needed.
 
 ## Examples
 
-### Github Actions
+### GitHub Actions
 
 ```yaml
 name: release
@@ -146,8 +168,9 @@ jobs:
       - run: npx semantic-release
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          # In case you want to publish to Visual Studio Marketplace
           VSCE_PAT: ${{ secrets.VSCE_PAT }}
-          # In case you want to publish to OpenVSX
+          # In case you want to publish to Open VSX Registry
           OVSX_PAT: ${{ secrets.OVSX_PAT }}
 ```
 
@@ -277,8 +300,9 @@ jobs:
           VSCE_TARGET: ${{ matrix.target }}
           # All tokens are required since semantic-release needs to validate them
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          # In case you want to publish to Visual Studio Marketplace
           VSCE_PAT: ${{ secrets.VSCE_PAT }}
-          # In case you want to publish to OpenVSX
+          # In case you want to publish to Open VSX Registry
           OVSX_PAT: ${{ secrets.OVSX_PAT }}
 
       - uses: actions/upload-artifact@v3
@@ -303,8 +327,9 @@ jobs:
       - run: npx semantic-release --extends ./publish.release.config.js
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          # In case you want to publish to Visual Studio Marketplace
           VSCE_PAT: ${{ secrets.VSCE_PAT }}
-          # In case you want to publish to OpenVSX
+          # In case you want to publish to Open VSX Registry
           OVSX_PAT: ${{ secrets.OVSX_PAT }}
 ```
 

package/index.js

@@ -15,7 +15,7 @@ async function verifyConditions(pluginConfig, { logger, cwd }) {
 
 async function prepare(
   pluginConfig,
-  { nextRelease: { version }, logger, cwd }
+  { nextRelease: { version }, logger, cwd },
 ) {
   if (!verified) {
     await verifyVsce(pluginConfig, { logger, cwd });
@@ -25,14 +25,14 @@ async function prepare(
     version,
     pluginConfig.packageVsix,
     logger,
-    cwd
+    cwd,
   );
   prepared = true;
 }
 
 async function publish(
   pluginConfig,
-  { nextRelease: { version }, logger, cwd }
+  { nextRelease: { version }, logger, cwd },
 ) {
   if (!verified) {
     await verifyVsce(pluginConfig, { logger, cwd });
@@ -45,7 +45,7 @@ async function publish(
       version,
       pluginConfig.packageVsix,
       logger,
-      cwd
+      cwd,
     );
   }
 

package/lib/prepare.js

@@ -2,19 +2,19 @@
 
 const execa = require('execa');
 const { readJson } = require('fs-extra');
-const { isOvsxEnabled, isTargetEnabled } = require('./utils');
+const { isOvsxPublishEnabled, isTargetEnabled } = require('./utils');
 
 module.exports = async (version, packageVsix, logger, cwd) => {
   if (packageVsix === false) {
     return;
   }
 
-  const ovsxEnabled = isOvsxEnabled();
+  const ovsxPublishEnabled = isOvsxPublishEnabled();
 
-  if (packageVsix || ovsxEnabled) {
-    if (!packageVsix && ovsxEnabled) {
+  if (packageVsix || ovsxPublishEnabled) {
+    if (!packageVsix && ovsxPublishEnabled) {
       logger.log(
-        'Packaging to VSIX even though `packageVsix` is not set as publish to OpenVSX is enabled.'
+        'Packaging to VSIX even though `packageVsix` is not set as publish to OpenVSX is enabled.',
       );
     }
 

package/lib/publish.js

@@ -2,7 +2,11 @@
 
 const execa = require('execa');
 const { readJson } = require('fs-extra');
-const { isOvsxEnabled, isTargetEnabled } = require('./utils');
+const {
+  isOvsxPublishEnabled,
+  isTargetEnabled,
+  isVscePublishEnabled,
+} = require('./utils');
 
 module.exports = async (version, packagePath, logger, cwd) => {
   const { publisher, name } = await readJson('./package.json');
@@ -27,38 +31,36 @@ module.exports = async (version, packagePath, logger, cwd) => {
       message += ` for target ${process.env.VSCE_TARGET}`;
     }
   }
-  message += ' to Visual Studio Marketplace';
-  logger.log(message);
 
-  await execa('vsce', options, { stdio: 'inherit', preferLocal: true, cwd });
+  const releases = [];
+  if (isVscePublishEnabled()) {
+    logger.log(message + ' to Visual Studio Marketplace');
 
-  const vsceUrl = `https://marketplace.visualstudio.com/items?itemName=${publisher}.${name}`;
-  logger.log(`The new version is available at ${vsceUrl}.`);
+    await execa('vsce', options, { stdio: 'inherit', preferLocal: true, cwd });
+    const vsceUrl = `https://marketplace.visualstudio.com/items?itemName=${publisher}.${name}`;
 
-  const vsceRelease = {
-    name: 'Visual Studio Marketplace',
-    url: vsceUrl,
-  };
+    logger.log(`The new version is available at ${vsceUrl}.`);
+    releases.push({
+      name: 'Visual Studio Marketplace',
+      url: vsceUrl,
+    });
+  }
 
-  if (isOvsxEnabled()) {
-    logger.log('Now publishing to OpenVSX');
+  if (isOvsxPublishEnabled()) {
+    logger.log(message + 'to Open VSX Registry');
 
     // When publishing to OpenVSX, packagePath will be always set
     await execa('ovsx', options, { stdio: 'inherit', preferLocal: true, cwd });
     const ovsxUrl = `https://open-vsx.org/extension/${publisher}/${name}/${version}`;
 
     logger.log(`The new ovsx version is available at ${ovsxUrl}`);
-
-    // TODO: uncomment after https://github.com/semantic-release/semantic-release/issues/2123
-    // const ovsxRelease = {
-    //   name: 'Open VSX Registry',
-    //   url: ovsxUrl
-    // };
-
-    // const releases = [vsceRelease, ovsxRelease];
-
-    // return releases;
+    releases.push({
+      name: 'Open VSX Registry',
+      url: ovsxUrl,
+    });
   }
 
-  return vsceRelease;
+  // TODO: uncomment after https://github.com/semantic-release/semantic-release/issues/2123
+  // return releases;
+  return releases.shift();
 };

package/lib/utils.js

@@ -1,7 +1,13 @@
-const isOvsxEnabled = () => {
+// @ts-check
+
+const isOvsxPublishEnabled = () => {
   return 'OVSX_PAT' in process.env;
 };
 
+const isVscePublishEnabled = () => {
+  return 'VSCE_PAT' in process.env;
+};
+
 const isTargetEnabled = () => {
   return (
     'VSCE_TARGET' in process.env && process.env.VSCE_TARGET !== 'universal'
@@ -10,5 +16,6 @@ const isTargetEnabled = () => {
 
 module.exports = {
   isTargetEnabled,
-  isOvsxEnabled,
+  isOvsxPublishEnabled,
+  isVscePublishEnabled,
 };

package/lib/verify-ovsx-auth.js

@@ -2,22 +2,14 @@
 
 const SemanticReleaseError = require('@semantic-release/error');
 const execa = require('execa');
-const { isOvsxEnabled } = require('./utils');
 
 module.exports = async (logger, cwd) => {
   logger.log('Verifying authentication for ovsx');
 
-  if (!isOvsxEnabled()) {
-    logger.log(
-      'Skipping verification of ovsx personal token because the `OVSX_PAT` environment variable is not set.\n\nDid you know you can easily start publishing to OpenVSX with `semantic-release-vsce`?\nLearn more at https://github.com/felipecrs/semantic-release-vsce#publishing-to-openvsx'
-    );
-    return;
-  }
-
   if (!process.env.OVSX_PAT) {
     throw new SemanticReleaseError(
-      'Empty ovsx personal access token specified.',
-      'EINVALIDOVSXPAT'
+      'Empty ovsx personal access token (`OVSX_PAT` environment variable) specified.',
+      'EEMPTYOVSXPAT',
     );
   }
 
@@ -26,7 +18,7 @@ module.exports = async (logger, cwd) => {
   } catch (e) {
     throw new SemanticReleaseError(
       `Invalid ovsx personal access token. Additional information:\n\n${e}`,
-      'EINVALIDOVSXPAT'
+      'EINVALIDOVSXPAT',
     );
   }
 };

package/lib/verify-pkg.js

@@ -8,7 +8,7 @@ module.exports = async () => {
   if (!fs.existsSync('./package.json')) {
     throw new SemanticReleaseError(
       'The `package.json` was not found. A `package.json` is required to release with vsce.',
-      'ENOPKG'
+      'ENOPKG',
     );
   }
 
@@ -16,10 +16,10 @@ module.exports = async () => {
 
   try {
     packageJson = await readJson('./package.json');
-  } catch (error) {
+  } catch {
     throw new SemanticReleaseError(
       'The `package.json` seems to be invalid.',
-      'EINVALIDPKG'
+      'EINVALIDPKG',
     );
   }
 
@@ -28,13 +28,13 @@ module.exports = async () => {
   if (!name) {
     throw new SemanticReleaseError(
       'No `name` found in `package.json`.',
-      'ENOPKGNAME'
+      'ENOPKGNAME',
     );
   }
   if (!publisher) {
     throw new SemanticReleaseError(
       'No `publisher` found in `package.json`.',
-      'ENOPUBLISHER'
+      'ENOPUBLISHER',
     );
   }
 };

package/lib/verify-target.js

@@ -11,7 +11,7 @@ module.exports = async () => {
   if (!process.env.VSCE_TARGET) {
     throw new SemanticReleaseError(
       'Empty vsce target specified.',
-      'EINVALIDVSCETARGET'
+      'EINVALIDVSCETARGET',
     );
   }
 
@@ -24,7 +24,7 @@ module.exports = async () => {
         `Unsupported vsce target: ${
           process.env.VSCE_TARGET
         }. Available targets: ${Object.values(targets).join(', ')}`,
-        'EUNSUPPORTEDVSCETARGET'
+        'EUNSUPPORTEDVSCETARGET',
       );
     }
   }

package/lib/{verify-auth.js → verify-vsce-auth.js}

@@ -1,15 +1,15 @@
 // @ts-check
 
-const execa = require('execa');
 const SemanticReleaseError = require('@semantic-release/error');
+const execa = require('execa');
 
 module.exports = async (logger, cwd) => {
   logger.log('Verifying authentication for vsce');
 
   if (!process.env.VSCE_PAT) {
     throw new SemanticReleaseError(
-      'No vsce personal access token specified (set the `VSCE_PAT` environment variable).',
-      'ENOVSCEPAT'
+      'Empty vsce personal access token (`VSCE_PAT` environment variable) specified.',
+      'EEMPTYVSCEPAT',
     );
   }
 
@@ -18,7 +18,7 @@ module.exports = async (logger, cwd) => {
   } catch (e) {
     throw new SemanticReleaseError(
       `Invalid vsce personal access token. Additional information:\n\n${e}`,
-      'EINVALIDVSCETOKEN'
+      'EINVALIDVSCEPAT',
     );
   }
 };

package/lib/verify.js

@@ -1,16 +1,38 @@
 // @ts-check
 
+const SemanticReleaseError = require('@semantic-release/error');
 const verifyPkg = require('./verify-pkg');
-const verifyAuth = require('./verify-auth');
+const verifyVsceAuth = require('./verify-vsce-auth');
 const verifyOvsxAuth = require('./verify-ovsx-auth');
 const verifyTarget = require('./verify-target');
+const { isOvsxPublishEnabled, isVscePublishEnabled } = require('./utils');
 
 module.exports = async (pluginConfig, { logger, cwd }) => {
   await verifyPkg();
   await verifyTarget();
 
   if (pluginConfig?.publish !== false) {
-    await verifyAuth(logger, cwd);
-    await verifyOvsxAuth(logger, cwd);
+    const vscePublishEnabled = isVscePublishEnabled();
+    const ovsxPublishEnabled = isOvsxPublishEnabled();
+    if (!vscePublishEnabled && !ovsxPublishEnabled) {
+      throw new SemanticReleaseError(
+        'No personal access token was detected. Set the `VSCE_PAT` or the `OVSX_PAT` environment variable, at least one of them must be present when publish is enabled.\nLearn more at https://github.com/felipecrs/semantic-release-vsce#publishing',
+        'ENOPAT',
+      );
+    }
+    if (vscePublishEnabled) {
+      await verifyVsceAuth(logger, cwd);
+    } else {
+      logger.log(
+        'Skipping verification of the vsce personal access token as the `VSCE_PAT` environment variable is not set.\n\nDid you know you can easily start publishing to Visual Studio Marketplace with `semantic-release-vsce`?\nLearn more at https://github.com/felipecrs/semantic-release-vsce#publishing-to-visual-studio-marketplace',
+      );
+    }
+    if (ovsxPublishEnabled) {
+      await verifyOvsxAuth(logger, cwd);
+    } else {
+      logger.log(
+        'Skipping verification of the ovsx personal access token as the `OVSX_PAT` environment variable is not set.\n\nDid you know you can easily start publishing to Open VSX Registry with `semantic-release-vsce`?\nLearn more at https://github.com/felipecrs/semantic-release-vsce#publishing-to-open-vsx-registry',
+      );
+    }
   }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "semantic-release-vsce",
-  "version": "5.5.10",
+  "version": "5.6.0",
   "description": "semantic-release plugin to package and publish VS Code extensions",
   "license": "MIT",
   "engines": {
@@ -43,8 +43,8 @@
     ]
   },
   "volta": {
-    "node": "18.12.1",
-    "npm": "9.1.1"
+    "node": "18.16.1",
+    "npm": "9.8.0"
   },
   "dependencies": {
     "@semantic-release/error": "^3.0.0",
@@ -69,7 +69,7 @@
     "husky": "^8.0.2",
     "lint-staged": "^13.0.3",
     "nyc": "^15.1.0",
-    "prettier": "2.8.8",
+    "prettier": "3.0.0",
     "proxyquire": "^2.1.3",
     "semantic-release": "^21.0.1",
     "sinon": "^15.0.0"

package/test/index.test.js

@@ -1,4 +1,4 @@
-const test = require('ava');
+const test = require('ava').serial;
 const sinon = require('sinon');
 const proxyquire = require('proxyquire');
 
@@ -44,7 +44,7 @@ test('verifyConditions', async (t) => {
     verifyVsceStub.calledOnceWith(pluginConfig, {
       logger: semanticReleasePayload.logger,
       cwd: semanticReleasePayload.cwd,
-    })
+    }),
   );
 });
 
@@ -63,7 +63,7 @@ test('prepare and unverified', async (t) => {
     verifyVsceStub.calledOnceWith(pluginConfig, {
       logger: semanticReleasePayload.logger,
       cwd: semanticReleasePayload.cwd,
-    })
+    }),
   );
   t.deepEqual(vscePrepareStub.getCall(0).args, [
     semanticReleasePayload.nextRelease.version,
@@ -166,7 +166,7 @@ test('it does not publish the package if publishing is disabled', async (t) => {
 
   await verifyConditions(
     { ...pluginConfig, publish: false },
-    semanticReleasePayload
+    semanticReleasePayload,
   );
   await prepare({ ...pluginConfig, publish: false }, semanticReleasePayload);
   await publish({ ...pluginConfig, publish: false }, semanticReleasePayload);
@@ -174,6 +174,32 @@ test('it does not publish the package if publishing is disabled', async (t) => {
   t.true(vscePublishStub.notCalled);
 });
 
+test('it can publish when `OVSX_PAT` is present but `VSCE_PAT` is missing', async (t) => {
+  const token = 'abc123';
+  sinon.stub(process, 'env').value({
+    OVSX_PAT: token,
+  });
+  const { verifyVsceStub, vscePrepareStub, vscePublishStub } = t.context.stubs;
+  const { prepare, publish, verifyConditions } = proxyquire('../index.js', {
+    './lib/verify': verifyVsceStub,
+    './lib/publish': vscePublishStub,
+    './lib/prepare': vscePrepareStub,
+  });
+
+  await verifyConditions({ ...pluginConfig }, semanticReleasePayload);
+  await prepare({ ...pluginConfig }, semanticReleasePayload);
+  await publish({ ...pluginConfig }, semanticReleasePayload);
+
+  t.true(verifyVsceStub.calledOnce);
+  t.true(vscePrepareStub.calledOnce);
+  t.deepEqual(vscePublishStub.getCall(0).args, [
+    semanticReleasePayload.nextRelease.version,
+    undefined,
+    semanticReleasePayload.logger,
+    semanticReleasePayload.cwd,
+  ]);
+});
+
 test('expand globs if publishPackagePath is set', async (t) => {
   const { verifyVsceStub, vscePrepareStub, vscePublishStub } = t.context.stubs;
   const { publish } = proxyquire('../index.js', {

package/test/publish.test.js

@@ -193,3 +193,61 @@ test('publish to OpenVSX', async (t) => {
     { stdio: 'inherit', preferLocal: true, cwd },
   ]);
 });
+
+test('publish to OpenVSX only', async (t) => {
+  const { execaStub } = t.context.stubs;
+  const publisher = 'semantic-release-vsce';
+  const name = 'Semantice Release VSCE';
+  const publish = proxyquire('../lib/publish', {
+    execa: execaStub,
+    'fs-extra': {
+      readJson: sinon.stub().returns({
+        publisher,
+        name,
+      }),
+    },
+  });
+
+  const version = '1.0.0';
+  const packagePath = 'test.vsix';
+  const token = 'abc123';
+  sinon.stub(process, 'env').value({
+    OVSX_PAT: token,
+  });
+  const result = await publish(version, packagePath, logger, cwd);
+
+  t.deepEqual(result, {
+    name: 'Open VSX Registry',
+    url: `https://open-vsx.org/extension/${publisher}/${name}/${version}`,
+  });
+  t.true(execaStub.calledOnce);
+  t.deepEqual(execaStub.getCall(0).args, [
+    'ovsx',
+    ['publish', '--packagePath', packagePath],
+    { stdio: 'inherit', preferLocal: true, cwd },
+  ]);
+});
+
+test('should not publish when neither vsce nor ovsx personal access token is configured', async (t) => {
+  const { execaStub } = t.context.stubs;
+  const publisher = 'semantic-release-vsce';
+  const name = 'Semantice Release VSCE';
+  const publish = proxyquire('../lib/publish', {
+    execa: execaStub,
+    'fs-extra': {
+      readJson: sinon.stub().returns({
+        publisher,
+        name,
+      }),
+    },
+  });
+
+  const version = '1.0.0';
+  const packagePath = 'test.vsix';
+  sinon.stub(process, 'env').value({});
+
+  const result = await publish(version, packagePath, logger, cwd);
+
+  t.falsy(result);
+  t.true(execaStub.notCalled);
+});

package/test/verify-ovsx-auth.test.js

@@ -1,21 +1,10 @@
-const test = require('ava');
+const test = require('ava').serial;
 const sinon = require('sinon');
 const proxyquire = require('proxyquire');
 const SemanticReleaseError = require('@semantic-release/error');
 
 const cwd = process.cwd();
 
-test('OVSX_PAT is not set', async (t) => {
-  const logger = {
-    log: sinon.fake(),
-  };
-
-  const verifyOvsxAuth = require('../lib/verify-ovsx-auth');
-
-  await t.notThrowsAsync(() => verifyOvsxAuth(logger));
-  t.true(logger.log.calledTwice);
-});
-
 test('OVSX_PAT is set', async (t) => {
   const logger = {
     log: sinon.fake(),
@@ -49,7 +38,7 @@ test('OVSX_PAT is invalid', async (t) => {
 
   await t.throwsAsync(() => verifyOvsxAuth(logger), {
     instanceOf: SemanticReleaseError,
-    code: 'EINVALIDOVSXPAT',
+    code: 'EEMPTYOVSXPAT',
   });
 });
 

package/test/{verify-auth.test.js → verify-vsce-auth.test.js}

@@ -1,4 +1,4 @@
-const test = require('ava');
+const test = require('ava').serial;
 const sinon = require('sinon');
 const proxyquire = require('proxyquire');
 const SemanticReleaseError = require('@semantic-release/error');
@@ -13,61 +13,62 @@ test('VSCE_PAT is set', async (t) => {
     VSCE_PAT: 'abc123',
   });
 
-  const verifyAuth = proxyquire('../lib/verify-auth', {
+  const verifyVsceAuth = proxyquire('../lib/verify-vsce-auth', {
     execa: sinon
       .stub()
       .withArgs('vsce', ['verify-pat'], { preferLocal: true, cwd })
       .resolves(),
   });
 
-  await t.notThrowsAsync(() => verifyAuth(logger));
+  await t.notThrowsAsync(() => verifyVsceAuth(logger));
 });
 
-test('VSCE_PAT is not set', async (t) => {
-  sinon.stub(process, 'env').value({});
+test('VSCE_PAT is valid', async (t) => {
+  sinon.stub(process, 'env').value({
+    VSCE_PAT: 'abc123',
+  });
 
-  const verifyAuth = proxyquire('../lib/verify-auth', {
+  const verifyVsceAuth = proxyquire('../lib/verify-vsce-auth', {
     execa: sinon
       .stub()
       .withArgs('vsce', ['verify-pat'], { preferLocal: true, cwd })
       .resolves(),
   });
 
-  await t.throwsAsync(() => verifyAuth(logger), {
-    instanceOf: SemanticReleaseError,
-    code: 'ENOVSCEPAT',
-  });
+  await t.notThrowsAsync(() => verifyVsceAuth(logger));
 });
 
-test('VSCE_PAT is valid', async (t) => {
+test('VSCE_PAT is invalid', async (t) => {
+  const logger = {
+    log: sinon.fake(),
+  };
+
   sinon.stub(process, 'env').value({
-    VSCE_PAT: 'abc123',
+    VSCE_PAT: '',
   });
 
-  const verifyAuth = proxyquire('../lib/verify-auth', {
-    execa: sinon
-      .stub()
-      .withArgs('vsce', ['verify-pat'], { preferLocal: true, cwd })
-      .resolves(),
-  });
+  const verifyOvsxAuth = require('../lib/verify-vsce-auth');
 
-  await t.notThrowsAsync(() => verifyAuth(logger));
+  await t.throwsAsync(() => verifyOvsxAuth(logger), {
+    instanceOf: SemanticReleaseError,
+    code: 'EEMPTYVSCEPAT',
+  });
 });
 
-test('VSCE_PAT is invalid', async (t) => {
+test('VSCE_PAT is invalid but not empty', async (t) => {
   sinon.stub(process, 'env').value({
     VSCE_PAT: 'abc123',
   });
 
-  const verifyAuth = proxyquire('../lib/verify-auth', {
+  const verifyVsceAuth = proxyquire('../lib/verify-vsce-auth', {
     execa: sinon
       .stub()
       .withArgs('vsce', ['verify-pat'], { preferLocal: true, cwd })
       .rejects(),
   });
 
-  await t.throwsAsync(() => verifyAuth(logger), {
+  await t.throwsAsync(() => verifyVsceAuth(logger), {
     instanceOf: SemanticReleaseError,
-    code: 'EINVALIDVSCETOKEN',
+    code: 'EINVALIDVSCEPAT',
   });
 });

package/test/verify.test.js

@@ -1,3 +1,4 @@
+const SemanticReleaseError = require('@semantic-release/error');
 const test = require('ava');
 const sinon = require('sinon');
 const proxyquire = require('proxyquire');
@@ -11,8 +12,12 @@ test('resolves', async (t) => {
   const verify = proxyquire('../lib/verify', {
     './verify-pkg': sinon.stub().resolves(),
     './verify-target': sinon.stub().resolves(),
-    './verify-auth': sinon.stub().resolves(),
+    './verify-vsce-auth': sinon.stub().resolves(),
     './verify-ovsx-auth': sinon.stub().resolves(),
+    './utils': {
+      isVscePublishEnabled: sinon.stub().returns(true),
+      isOvsxPublishEnabled: sinon.stub().returns(true),
+    },
   });
 
   await t.notThrowsAsync(() => verify({}, { logger, cwd }));
@@ -22,7 +27,7 @@ test('rejects with verify-pkg', async (t) => {
   const verify = proxyquire('../lib/verify', {
     './verify-pkg': sinon.stub().rejects(),
     './verify-target': sinon.stub().resolves(),
-    './verify-auth': sinon.stub().resolves(),
+    './verify-vsce-auth': sinon.stub().resolves(),
     './verify-ovsx-auth': sinon.stub().resolves(),
   });
 
@@ -33,7 +38,7 @@ test('rejects with verify-target', async (t) => {
   const verify = proxyquire('../lib/verify', {
     './verify-pkg': sinon.stub().resolves(),
     './verify-target': sinon.stub().rejects(),
-    './verify-auth': sinon.stub().resolves(),
+    './verify-vsce-auth': sinon.stub().resolves(),
     './verify-ovsx-auth': sinon.stub().resolves(),
   });
 
@@ -44,7 +49,7 @@ test('rejects with verify-auth', async (t) => {
   const verify = proxyquire('../lib/verify', {
     './verify-pkg': sinon.stub().resolves(),
     './verify-target': sinon.stub().resolves(),
-    './verify-auth': sinon.stub().rejects(),
+    './verify-vsce-auth': sinon.stub().rejects(),
     './verify-ovsx-auth': sinon.stub().resolves(),
   });
 
@@ -55,29 +60,112 @@ test('rejects with verify-ovsx-auth', async (t) => {
   const verify = proxyquire('../lib/verify', {
     './verify-pkg': sinon.stub().resolves(),
     './verify-target': sinon.stub().resolves(),
-    './verify-auth': sinon.stub().resolves(),
+    './verify-vsce-auth': sinon.stub().resolves(),
     './verify-ovsx-auth': sinon.stub().rejects(),
   });
 
   await t.throwsAsync(() => verify({}, { logger, cwd }));
 });
 
-test('is does not verify the auth tokens if publishing is disabled', async (t) => {
+test('it does not verify the auth tokens if publishing is disabled', async (t) => {
   const stubs = {
     verifyPkgStub: sinon.stub().resolves(),
     verifyTargetStub: sinon.stub().resolves(),
-    verifyAuthStub: sinon.stub().resolves(),
+    verifyVsceAuthStub: sinon.stub().resolves(),
     verifyOvsxAuthStub: sinon.stub().resolves(),
   };
   const verify = proxyquire('../lib/verify', {
     './verify-pkg': stubs.verifyPkgStub,
     './verify-target': stubs.verifyTargetStub,
-    './verify-auth': stubs.verifyAuthStub,
+    './verify-vsce-auth': stubs.verifyVsceAuthStub,
     './verify-ovsx-auth': stubs.verifyOvsxAuthStub,
   });
 
   await verify({ publish: false }, { logger, cwd });
 
-  t.true(stubs.verifyAuthStub.notCalled);
+  t.true(stubs.verifyVsceAuthStub.notCalled);
   t.true(stubs.verifyOvsxAuthStub.notCalled);
 });
+
+test('errors when neither vsce nor ovsx personal access token is configured', async (t) => {
+  const stubs = {
+    verifyPkgStub: sinon.stub().resolves(),
+    verifyTargetStub: sinon.stub().resolves(),
+    verifyVsceAuthStub: sinon.stub().resolves(),
+    verifyOvsxAuthStub: sinon.stub().resolves(),
+    utilsStub: {
+      isVscePublishEnabled: sinon.stub().returns(false),
+      isOvsxPublishEnabled: sinon.stub().returns(false),
+    },
+  };
+  const verify = proxyquire('../lib/verify', {
+    './verify-pkg': stubs.verifyPkgStub,
+    './verify-target': stubs.verifyTargetStub,
+    './verify-vsce-auth': stubs.verifyVsceAuthStub,
+    './verify-ovsx-auth': stubs.verifyOvsxAuthStub,
+    './utils': stubs.utilsStub,
+  });
+
+  await t.throwsAsync(() => verify({}, { logger, cwd }), {
+    instanceOf: SemanticReleaseError,
+    code: 'ENOPAT',
+  });
+  t.true(stubs.verifyVsceAuthStub.notCalled);
+  t.true(stubs.verifyOvsxAuthStub.notCalled);
+});
+
+test('verify vsce only', async (t) => {
+  const stubs = {
+    verifyPkgStub: sinon.stub().resolves(),
+    verifyTargetStub: sinon.stub().resolves(),
+    verifyVsceAuthStub: sinon.stub().resolves(),
+    verifyOvsxAuthStub: sinon.stub().resolves(),
+    utilsStub: {
+      isVscePublishEnabled: sinon.stub().returns(true),
+      isOvsxPublishEnabled: sinon.stub().returns(false),
+    },
+    logger: {
+      log: sinon.fake(),
+    },
+  };
+  const verify = proxyquire('../lib/verify', {
+    './verify-pkg': stubs.verifyPkgStub,
+    './verify-target': stubs.verifyTargetStub,
+    './verify-vsce-auth': stubs.verifyVsceAuthStub,
+    './verify-ovsx-auth': stubs.verifyOvsxAuthStub,
+    './utils': stubs.utilsStub,
+  });
+
+  await verify({}, { logger: stubs.logger, cwd });
+  t.true(stubs.verifyVsceAuthStub.calledOnce);
+  t.true(stubs.verifyOvsxAuthStub.notCalled);
+  t.true(stubs.logger.log.calledOnce);
+});
+
+test('verify ovsx only', async (t) => {
+  const stubs = {
+    verifyPkgStub: sinon.stub().resolves(),
+    verifyTargetStub: sinon.stub().resolves(),
+    verifyVsceAuthStub: sinon.stub().resolves(),
+    verifyOvsxAuthStub: sinon.stub().resolves(),
+    utilsStub: {
+      isVscePublishEnabled: sinon.stub().returns(false),
+      isOvsxPublishEnabled: sinon.stub().returns(true),
+    },
+    logger: {
+      log: sinon.fake(),
+    },
+  };
+  const verify = proxyquire('../lib/verify', {
+    './verify-pkg': stubs.verifyPkgStub,
+    './verify-target': stubs.verifyTargetStub,
+    './verify-vsce-auth': stubs.verifyVsceAuthStub,
+    './verify-ovsx-auth': stubs.verifyOvsxAuthStub,
+    './utils': stubs.utilsStub,
+  });
+
+  await verify({}, { logger: stubs.logger, cwd });
+  t.true(stubs.verifyVsceAuthStub.notCalled);
+  t.true(stubs.verifyOvsxAuthStub.calledOnce);
+  t.true(stubs.logger.log.calledOnce);
+});

package/.prettierignore

@@ -1 +0,0 @@
-.nyc_output