semantic-release-vsce 5.2.4 → 5.4.0

package/test/publish.test.js

@@ -1,23 +1,24 @@
+// Run tests serially to avoid env pollution
+const test = require('ava').serial;
 const sinon = require('sinon');
-const test = require('ava');
 const proxyquire = require('proxyquire');
 
 const logger = {
-  log: sinon.fake()
+  log: sinon.fake(),
 };
 const cwd = process.cwd();
 
-test.beforeEach(t => {
+test.beforeEach((t) => {
   t.context.stubs = {
-    execaStub: sinon.stub()
+    execaStub: sinon.stub(),
   };
 });
 
-test.afterEach(t => {
+test.afterEach((t) => {
   t.context.stubs.execaStub.resetHistory();
 });
 
-test('publish', async t => {
+test('publish', async (t) => {
   const { execaStub } = t.context.stubs;
   const publisher = 'semantic-release-vsce';
   const name = 'Semantice Release VSCE';
@@ -26,26 +27,30 @@ test('publish', async t => {
     'fs-extra': {
       readJson: sinon.stub().returns({
         publisher,
-        name
-      })
-    }
+        name,
+      }),
+    },
   });
 
   const version = '1.0.0';
   const token = 'abc123';
   sinon.stub(process, 'env').value({
-    VSCE_PAT: token
+    VSCE_PAT: token,
   });
   const result = await publish(version, undefined, logger, cwd);
 
   t.deepEqual(result, {
     name: 'Visual Studio Marketplace',
-    url: `https://marketplace.visualstudio.com/items?itemName=${publisher}.${name}`
+    url: `https://marketplace.visualstudio.com/items?itemName=${publisher}.${name}`,
   });
-  t.deepEqual(execaStub.getCall(0).args, ['vsce', ['publish', version, '--no-git-tag-version'], { stdio: 'inherit', preferLocal: true, cwd }]);
+  t.deepEqual(execaStub.getCall(0).args, [
+    'vsce',
+    ['publish', version, '--no-git-tag-version'],
+    { stdio: 'inherit', preferLocal: true, cwd },
+  ]);
 });
 
-test('publish with packagePath', async t => {
+test('publish with packagePath', async (t) => {
   const { execaStub } = t.context.stubs;
   const publisher = 'semantic-release-vsce';
   const name = 'Semantice Release VSCE';
@@ -54,27 +59,31 @@ test('publish with packagePath', async t => {
     'fs-extra': {
       readJson: sinon.stub().returns({
         publisher,
-        name
-      })
-    }
+        name,
+      }),
+    },
   });
 
   const version = '1.0.0';
   const packagePath = 'test.vsix';
   const token = 'abc123';
   sinon.stub(process, 'env').value({
-    VSCE_PAT: token
+    VSCE_PAT: token,
   });
   const result = await publish(version, packagePath, logger, cwd);
 
   t.deepEqual(result, {
     name: 'Visual Studio Marketplace',
-    url: `https://marketplace.visualstudio.com/items?itemName=${publisher}.${name}`
+    url: `https://marketplace.visualstudio.com/items?itemName=${publisher}.${name}`,
   });
-  t.deepEqual(execaStub.getCall(0).args, ['vsce', ['publish', '--packagePath', packagePath], { stdio: 'inherit', preferLocal: true, cwd }]);
+  t.deepEqual(execaStub.getCall(0).args, [
+    'vsce',
+    ['publish', '--packagePath', packagePath],
+    { stdio: 'inherit', preferLocal: true, cwd },
+  ]);
 });
 
-test('publish to OpenVSX', async t => {
+test('publish with multiple packagePath', async (t) => {
   const { execaStub } = t.context.stubs;
   const publisher = 'semantic-release-vsce';
   const name = 'Semantice Release VSCE';
@@ -83,9 +92,76 @@ test('publish to OpenVSX', async t => {
     'fs-extra': {
       readJson: sinon.stub().returns({
         publisher,
-        name
-      })
-    }
+        name,
+      }),
+    },
+  });
+
+  const version = '1.0.0';
+  const packagePath = ['test.vsix', 'test2.vsix'];
+  const token = 'abc123';
+  sinon.stub(process, 'env').value({
+    VSCE_PAT: token,
+  });
+  const result = await publish(version, packagePath, logger, cwd);
+
+  t.deepEqual(result, {
+    name: 'Visual Studio Marketplace',
+    url: `https://marketplace.visualstudio.com/items?itemName=${publisher}.${name}`,
+  });
+  t.deepEqual(execaStub.getCall(0).args, [
+    'vsce',
+    ['publish', '--packagePath', ...packagePath],
+    { stdio: 'inherit', preferLocal: true, cwd },
+  ]);
+});
+
+test('publish with target', 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 token = 'abc123';
+  const target = 'linux-x64';
+  sinon.stub(process, 'env').value({
+    VSCE_PAT: token,
+    VSCE_TARGET: target,
+  });
+  const result = await publish(version, undefined, logger, cwd);
+
+  t.deepEqual(result, {
+    name: 'Visual Studio Marketplace',
+    url: `https://marketplace.visualstudio.com/items?itemName=${publisher}.${name}`,
+  });
+  t.deepEqual(execaStub.getCall(0).args, [
+    'vsce',
+    ['publish', version, '--no-git-tag-version', '--target', target],
+    { stdio: 'inherit', preferLocal: true, cwd },
+  ]);
+});
+
+test('publish to OpenVSX', 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';
@@ -93,19 +169,27 @@ test('publish to OpenVSX', async t => {
   const token = 'abc123';
   sinon.stub(process, 'env').value({
     OVSX_PAT: token,
-    VSCE_PAT: token
+    VSCE_PAT: token,
   });
   const result = await publish(version, packagePath, logger, cwd);
 
   t.deepEqual(result, {
     name: 'Visual Studio Marketplace',
-    url: `https://marketplace.visualstudio.com/items?itemName=${publisher}.${name}`
+    url: `https://marketplace.visualstudio.com/items?itemName=${publisher}.${name}`,
   });
-  t.deepEqual(execaStub.getCall(0).args, ['vsce', ['publish', '--packagePath', packagePath], { stdio: 'inherit', preferLocal: true, cwd }]);
+  t.deepEqual(execaStub.getCall(0).args, [
+    'vsce',
+    ['publish', '--packagePath', packagePath],
+    { stdio: 'inherit', preferLocal: true, cwd },
+  ]);
 
   // t.deepEqual(result[1], {
   //   name: 'Open VSX Registry',
   //   url: `https://open-vsx.org/extension/${publisher}/${name}/${version}`
   // });
-  t.deepEqual(execaStub.getCall(1).args, ['ovsx', ['publish', packagePath], { stdio: 'inherit', preferLocal: true, cwd }]);
+  t.deepEqual(execaStub.getCall(1).args, [
+    'ovsx',
+    ['publish', '--packagePath', packagePath],
+    { stdio: 'inherit', preferLocal: true, cwd },
+  ]);
 });

package/test/verify-auth.test.js

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

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

@@ -1,27 +1,71 @@
 const test = require('ava');
 const sinon = require('sinon');
+const proxyquire = require('proxyquire');
 const SemanticReleaseError = require('@semantic-release/error');
 
-const logger = {
-  log: sinon.fake()
-};
+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(),
+  };
 
-test('OVSX_PAT is set', async t => {
   sinon.stub(process, 'env').value({
-    OVSX_PAT: 'abc123'
+    OVSX_PAT: 'abc123',
   });
 
-  const verifyOvsxAuth = require('../lib/verify-ovsx-auth');
+  const verifyOvsxAuth = proxyquire('../lib/verify-ovsx-auth', {
+    execa: sinon
+      .stub()
+      .withArgs('ovsx', ['verify-pat'], { preferLocal: true, cwd })
+      .resolves(),
+  });
 
   await t.notThrowsAsync(() => verifyOvsxAuth(logger));
+  t.true(logger.log.calledOnce);
+});
+
+test('OVSX_PAT is invalid', async (t) => {
+  const logger = {
+    log: sinon.fake(),
+  };
+
+  sinon.stub(process, 'env').value({
+    OVSX_PAT: '',
+  });
+
+  const verifyOvsxAuth = require('../lib/verify-ovsx-auth');
+
+  await t.throwsAsync(() => verifyOvsxAuth(logger), {
+    instanceOf: SemanticReleaseError,
+    code: 'EINVALIDOVSXPAT',
+  });
 });
 
-test('OVSX_PAT is invalid', async t => {
+test('OVSX_PAT is invalid but not empty', async (t) => {
+  const logger = {
+    log: sinon.fake(),
+  };
+
   sinon.stub(process, 'env').value({
-    OVSX_PAT: ''
+    OVSX_PAT: 'abc123',
   });
 
   const verifyOvsxAuth = require('../lib/verify-ovsx-auth');
 
-  await t.throwsAsync(() => verifyOvsxAuth(logger), { instanceOf: SemanticReleaseError, code: 'EINVALIDOVSXPAT' });
+  await t.throwsAsync(() => verifyOvsxAuth(logger), {
+    instanceOf: SemanticReleaseError,
+    code: 'EINVALIDOVSXPAT',
+  });
 });

package/test/verify-pkg.test.js

@@ -3,103 +3,115 @@ const test = require('ava');
 const proxyquire = require('proxyquire');
 const SemanticReleaseError = require('@semantic-release/error');
 
-test('package.json is found', async t => {
+test('package.json is found', async (t) => {
   const name = 'test';
   const publisher = 'tester';
 
   const verifyPkg = proxyquire('../lib/verify-pkg', {
     fs: {
-      existsSync: sinon.stub().returns(true)
+      existsSync: sinon.stub().returns(true),
     },
     'fs-extra': {
       readJson: sinon.stub().returns({
         name,
-        publisher
-      })
-    }
+        publisher,
+      }),
+    },
   });
 
   await t.notThrowsAsync(() => verifyPkg());
 });
 
-test('package.json is not found', async t => {
+test('package.json is not found', async (t) => {
   const name = 'test';
   const publisher = 'tester';
 
   const verifyPkg = proxyquire('../lib/verify-pkg', {
     fs: {
-      existsSync: sinon.stub().returns(false)
+      existsSync: sinon.stub().returns(false),
     },
     'fs-extra': {
       readJson: sinon.stub().returns({
         name,
-        publisher
-      })
-    }
+        publisher,
+      }),
+    },
   });
 
-  await t.throwsAsync(() => verifyPkg(), { instanceOf: SemanticReleaseError, code: 'ENOPKG' });
+  await t.throwsAsync(() => verifyPkg(), {
+    instanceOf: SemanticReleaseError,
+    code: 'ENOPKG',
+  });
 });
 
-test('package is valid', async t => {
+test('package is valid', async (t) => {
   const name = 'test';
   const publisher = 'tester';
   const verifyPkg = proxyquire('../lib/verify-pkg', {
     fs: {
-      existsSync: sinon.stub().returns(true)
+      existsSync: sinon.stub().returns(true),
     },
     'fs-extra': {
       readJson: sinon.stub().returns({
         publisher,
-        name
-      })
-    }
+        name,
+      }),
+    },
   });
 
   await t.notThrowsAsync(() => verifyPkg());
 });
 
-test('package is invalid', async t => {
+test('package is invalid', async (t) => {
   const verifyPkg = proxyquire('../lib/verify-pkg', {
     fs: {
-      existsSync: sinon.stub().returns(true)
+      existsSync: sinon.stub().returns(true),
     },
     'fs-extra': {
-      readJson: sinon.stub().rejects()
-    }
+      readJson: sinon.stub().rejects(),
+    },
   });
 
-  await t.throwsAsync(() => verifyPkg(), { instanceOf: SemanticReleaseError, code: 'EINVALIDPKG' });
+  await t.throwsAsync(() => verifyPkg(), {
+    instanceOf: SemanticReleaseError,
+    code: 'EINVALIDPKG',
+  });
 });
 
-test('package is missing name', async t => {
+test('package is missing name', async (t) => {
   const publisher = 'tester';
   const verifyPkg = proxyquire('../lib/verify-pkg', {
     fs: {
-      existsSync: sinon.stub().returns(true)
+      existsSync: sinon.stub().returns(true),
     },
     'fs-extra': {
       readJson: sinon.stub().returns({
-        publisher
-      })
-    }
+        publisher,
+      }),
+    },
   });
 
-  await t.throwsAsync(() => verifyPkg(), { instanceOf: SemanticReleaseError, code: 'ENOPKGNAME' });
+  await t.throwsAsync(() => verifyPkg(), {
+    instanceOf: SemanticReleaseError,
+    code: 'ENOPKGNAME',
+  });
 });
 
-test('package is missing publisher', async t => {
+test('package is missing publisher', async (t) => {
   const name = 'test';
   const verifyPkg = proxyquire('../lib/verify-pkg', {
     fs: {
-      existsSync: sinon.stub().returns(true)
+      existsSync: sinon.stub().returns(true),
     },
     'fs-extra': {
       readJson: sinon.stub().returns({
-        name
-      })
-    }
+        name,
+      }),
+    },
   });
 
-  await t.throwsAsync(() => verifyPkg(), { instanceOf: SemanticReleaseError, code: 'ENOPUBLISHER' });
+  await t.throwsAsync(() => verifyPkg(), {
+    instanceOf: SemanticReleaseError,
+    code: 'ENOPUBLISHER',
+  });
 });

package/test/verify-target.test.js

@@ -0,0 +1,55 @@
+const sinon = require('sinon');
+const test = require('ava');
+const proxyquire = require('proxyquire');
+const SemanticReleaseError = require('@semantic-release/error');
+
+test('VSCE_TARGET is not set', async (t) => {
+  const vscePackage = sinon.stub().returns({
+    Targets: new Map(),
+  });
+  const verifyTarget = proxyquire('../lib/verify-target', {
+    'vsce/out/package': vscePackage,
+  });
+
+  await t.notThrowsAsync(() => verifyTarget());
+});
+
+test('VSCE_TARGET is valid', async (t) => {
+  sinon.stub(process, 'env').value({
+    VSCE_TARGET: 'linux-x64',
+  });
+
+  const verifyTarget = require('../lib/verify-target');
+
+  await t.notThrowsAsync(() => verifyTarget());
+});
+
+test('VSCE_TARGET is empty', async (t) => {
+  const vscePackage = sinon.stub().returns({
+    Targets: new Map(),
+  });
+  const verifyTarget = proxyquire('../lib/verify-target', {
+    'vsce/out/package': vscePackage,
+  });
+  sinon.stub(process, 'env').value({
+    VSCE_TARGET: '',
+  });
+
+  await t.throwsAsync(() => verifyTarget(), {
+    instanceOf: SemanticReleaseError,
+    code: 'EINVALIDVSCETARGET',
+  });
+  t.false(vscePackage.called);
+});
+
+test('VSCE_TARGET is unsupported', async (t) => {
+  sinon.stub(process, 'env').value({
+    VSCE_TARGET: 'whatever-x64',
+  });
+  const verifyTarget = require('../lib/verify-target');
+
+  await t.throwsAsync(() => verifyTarget(), {
+    instanceOf: SemanticReleaseError,
+    code: 'EUNSUPPORTEDVSCETARGET',
+  });
+});

package/test/verify.test.js

@@ -3,47 +3,77 @@ const sinon = require('sinon');
 const proxyquire = require('proxyquire');
 
 const logger = {
-  log: sinon.fake()
+  log: sinon.fake(),
 };
 const cwd = process.cwd();
 
-test('resolves', async t => {
+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-pkg': sinon.stub().resolves()
+    './verify-ovsx-auth': sinon.stub().resolves(),
   });
 
   await t.notThrowsAsync(() => verify({}, { logger, cwd }));
 });
 
-test('rejects with verify-auth', async t => {
+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-ovsx-auth': sinon.stub().resolves(),
+  });
+
+  await t.throwsAsync(() => verify({}, { logger, cwd }));
+});
+
+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-ovsx-auth': sinon.stub().resolves(),
+  });
+
+  await t.throwsAsync(() => verify({}, { logger, cwd }));
+});
+
+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-pkg': sinon.stub().resolves()
+    './verify-ovsx-auth': sinon.stub().resolves(),
   });
 
   await t.throwsAsync(() => verify({}, { logger, cwd }));
 });
 
-test('rejects with verify-pkg', async t => {
+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-pkg': sinon.stub().rejects()
+    './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('is 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(),
-    verifyOvsxAuthStub: 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-ovsx-auth': stubs.verifyOvsxAuthStub
+    './verify-ovsx-auth': stubs.verifyOvsxAuthStub,
   });
 
   await verify({ publish: false }, { logger, cwd });

package/.husky/commit-msg

@@ -1,4 +0,0 @@
-#!/bin/sh
-. "$(dirname "$0")/_/husky.sh"
-
-npx --no-install commitlint --edit "$1"