semantic-release-vsce 5.7.3 → 6.0.0

package/test/publish.test.js

@@ -1,16 +1,18 @@
+import avaTest from 'ava';
+import { fake, stub } from 'sinon';
+import esmock from 'esmock';
+
 // Run tests serially to avoid env pollution
-const test = require('ava').serial;
-const sinon = require('sinon');
-const proxyquire = require('proxyquire');
+const test = avaTest.serial;
 
 const logger = {
-  log: sinon.fake(),
+  log: fake(),
 };
 const cwd = process.cwd();
 
 test.beforeEach((t) => {
   t.context.stubs = {
-    execaStub: sinon.stub(),
+    execaStub: stub(),
   };
 });
 
@@ -18,14 +20,16 @@ test.afterEach((t) => {
   t.context.stubs.execaStub.resetHistory();
 });
 
-test('publish', async (t) => {
+test('publish to vs marketplace with VSCE_PAT', 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({
+  const { publish } = await esmock('../lib/publish.js', {
+    execa: {
+      execa: execaStub,
+    },
+    'fs-extra/esm': {
+      readJson: stub().resolves({
         publisher,
         name,
       }),
@@ -34,7 +38,7 @@ test('publish', async (t) => {
 
   const version = '1.0.0';
   const token = 'abc123';
-  sinon.stub(process, 'env').value({
+  stub(process, 'env').value({
     VSCE_PAT: token,
   });
   const result = await publish(version, undefined, logger, cwd);
@@ -50,14 +54,86 @@ test('publish', async (t) => {
   ]);
 });
 
+test('publish to vs marketplace with VSCE_AZURE_CREDENTIAL=true', async (t) => {
+  const { execaStub } = t.context.stubs;
+  const publisher = 'semantic-release-vsce';
+  const name = 'Semantice Release VSCE';
+  const { publish } = await esmock('../lib/publish.js', {
+    execa: {
+      execa: execaStub,
+    },
+    'fs-extra/esm': {
+      readJson: stub().resolves({
+        publisher,
+        name,
+      }),
+    },
+  });
+
+  const version = '1.0.0';
+  const packagePath = 'test.vsix';
+  stub(process, 'env').value({
+    VSCE_AZURE_CREDENTIAL: 'true',
+  });
+  const result = await publish(version, packagePath, logger, cwd);
+
+  t.deepEqual(result, {
+    name: 'Visual Studio Marketplace',
+    url: `https://marketplace.visualstudio.com/items?itemName=${publisher}.${name}`,
+  });
+  const args0 = execaStub.getCall(0).args;
+  t.deepEqual(args0, [
+    'vsce',
+    ['publish', '--packagePath', packagePath, '--azure-credential'],
+    { stdio: 'inherit', preferLocal: true, cwd },
+  ]);
+});
+
+test('publish to vs marketplace with VSCE_AZURE_CREDENTIAL=1', async (t) => {
+  const { execaStub } = t.context.stubs;
+  const publisher = 'semantic-release-vsce';
+  const name = 'Semantice Release VSCE';
+  const { publish } = await esmock('../lib/publish.js', {
+    execa: {
+      execa: execaStub,
+    },
+    'fs-extra/esm': {
+      readJson: stub().resolves({
+        publisher,
+        name,
+      }),
+    },
+  });
+
+  const version = '1.0.0';
+  const packagePath = 'test.vsix';
+  stub(process, 'env').value({
+    VSCE_AZURE_CREDENTIAL: '1',
+  });
+  const result = await publish(version, packagePath, logger, cwd);
+
+  t.deepEqual(result, {
+    name: 'Visual Studio Marketplace',
+    url: `https://marketplace.visualstudio.com/items?itemName=${publisher}.${name}`,
+  });
+  const args0 = execaStub.getCall(0).args;
+  t.deepEqual(args0, [
+    'vsce',
+    ['publish', '--packagePath', packagePath, '--azure-credential'],
+    { stdio: 'inherit', preferLocal: true, cwd },
+  ]);
+});
+
 test('publish with packagePath', 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({
+  const { publish } = await esmock('../lib/publish.js', {
+    execa: {
+      execa: execaStub,
+    },
+    'fs-extra/esm': {
+      readJson: stub().resolves({
         publisher,
         name,
       }),
@@ -67,7 +143,7 @@ test('publish with packagePath', async (t) => {
   const version = '1.0.0';
   const packagePath = 'test.vsix';
   const token = 'abc123';
-  sinon.stub(process, 'env').value({
+  stub(process, 'env').value({
     VSCE_PAT: token,
   });
   const result = await publish(version, packagePath, logger, cwd);
@@ -87,10 +163,12 @@ test('publish with multiple packagePath', 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({
+  const { publish } = await esmock('../lib/publish.js', {
+    execa: {
+      execa: execaStub,
+    },
+    'fs-extra/esm': {
+      readJson: stub().resolves({
         publisher,
         name,
       }),
@@ -100,7 +178,7 @@ test('publish with multiple packagePath', async (t) => {
   const version = '1.0.0';
   const packagePath = ['test.vsix', 'test2.vsix'];
   const token = 'abc123';
-  sinon.stub(process, 'env').value({
+  stub(process, 'env').value({
     VSCE_PAT: token,
   });
   const result = await publish(version, packagePath, logger, cwd);
@@ -120,10 +198,12 @@ 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({
+  const { publish } = await esmock('../lib/publish.js', {
+    execa: {
+      execa: execaStub,
+    },
+    'fs-extra/esm': {
+      readJson: stub().resolves({
         publisher,
         name,
       }),
@@ -133,7 +213,7 @@ test('publish with target', async (t) => {
   const version = '1.0.0';
   const token = 'abc123';
   const target = 'linux-x64';
-  sinon.stub(process, 'env').value({
+  stub(process, 'env').value({
     VSCE_PAT: token,
     VSCE_TARGET: target,
   });
@@ -154,10 +234,12 @@ 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({
+  const { publish } = await esmock('../lib/publish.js', {
+    execa: {
+      execa: execaStub,
+    },
+    'fs-extra/esm': {
+      readJson: stub().resolves({
         publisher,
         name,
       }),
@@ -167,7 +249,7 @@ test('publish to OpenVSX', async (t) => {
   const version = '1.0.0';
   const packagePath = 'test.vsix';
   const token = 'abc123';
-  sinon.stub(process, 'env').value({
+  stub(process, 'env').value({
     OVSX_PAT: token,
     VSCE_PAT: token,
   });
@@ -198,10 +280,12 @@ 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({
+  const { publish } = await esmock('../lib/publish.js', {
+    execa: {
+      execa: execaStub,
+    },
+    'fs-extra/esm': {
+      readJson: stub().resolves({
         publisher,
         name,
       }),
@@ -211,7 +295,7 @@ test('publish to OpenVSX only', async (t) => {
   const version = '1.0.0';
   const packagePath = 'test.vsix';
   const token = 'abc123';
-  sinon.stub(process, 'env').value({
+  stub(process, 'env').value({
     OVSX_PAT: token,
   });
   const result = await publish(version, packagePath, logger, cwd);
@@ -232,10 +316,38 @@ test('should not publish when neither vsce nor ovsx personal access token is con
   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({
+  const { publish } = await esmock('../lib/publish.js', {
+    execa: {
+      execa: execaStub,
+    },
+    'fs-extra/esm': {
+      readJson: stub().resolves({
+        publisher,
+        name,
+      }),
+    },
+  });
+
+  const version = '1.0.0';
+  const packagePath = 'test.vsix';
+  stub(process, 'env').value({});
+
+  const result = await publish(version, packagePath, logger, cwd);
+
+  t.falsy(result);
+  t.true(execaStub.notCalled);
+});
+
+test('should not publish if no token and VSCE_AZURE_CREDENTIAL=false', async (t) => {
+  const { execaStub } = t.context.stubs;
+  const publisher = 'semantic-release-vsce';
+  const name = 'Semantice Release VSCE';
+  const { publish } = await esmock('../lib/publish.js', {
+    execa: {
+      execa: execaStub,
+    },
+    'fs-extra/esm': {
+      readJson: stub().resolves({
         publisher,
         name,
       }),
@@ -244,7 +356,9 @@ test('should not publish when neither vsce nor ovsx personal access token is con
 
   const version = '1.0.0';
   const packagePath = 'test.vsix';
-  sinon.stub(process, 'env').value({});
+  stub(process, 'env').value({
+    VSCE_AZURE_CREDENTIAL: 'false',
+  });
 
   const result = await publish(version, packagePath, logger, cwd);
 

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

@@ -1,24 +1,28 @@
-const test = require('ava').serial;
-const sinon = require('sinon');
-const proxyquire = require('proxyquire');
-const SemanticReleaseError = require('@semantic-release/error');
+import avaTest from 'ava';
+import { fake, stub } from 'sinon';
+import esmock from 'esmock';
+import SemanticReleaseError from '@semantic-release/error';
+
+// Run tests serially to avoid env pollution
+const test = avaTest.serial;
 
 const cwd = process.cwd();
 
 test('OVSX_PAT is set', async (t) => {
   const logger = {
-    log: sinon.fake(),
+    log: fake(),
   };
 
-  sinon.stub(process, 'env').value({
+  stub(process, 'env').value({
     OVSX_PAT: 'abc123',
   });
 
-  const verifyOvsxAuth = proxyquire('../lib/verify-ovsx-auth', {
-    execa: sinon
-      .stub()
-      .withArgs('ovsx', ['verify-pat'], { preferLocal: true, cwd })
-      .resolves(),
+  const { verifyOvsxAuth } = await esmock('../lib/verify-ovsx-auth.js', {
+    execa: {
+      execa: stub()
+        .withArgs('ovsx', ['verify-pat'], { preferLocal: true, cwd })
+        .resolves(),
+    },
   });
 
   await t.notThrowsAsync(() => verifyOvsxAuth(logger));
@@ -27,14 +31,14 @@ test('OVSX_PAT is set', async (t) => {
 
 test('OVSX_PAT is invalid', async (t) => {
   const logger = {
-    log: sinon.fake(),
+    log: fake(),
   };
 
-  sinon.stub(process, 'env').value({
+  stub(process, 'env').value({
     OVSX_PAT: '',
   });
 
-  const verifyOvsxAuth = require('../lib/verify-ovsx-auth');
+  const { verifyOvsxAuth } = await import('../lib/verify-ovsx-auth.js');
 
   await t.throwsAsync(() => verifyOvsxAuth(logger), {
     instanceOf: SemanticReleaseError,
@@ -44,14 +48,14 @@ test('OVSX_PAT is invalid', async (t) => {
 
 test('OVSX_PAT is invalid but not empty', async (t) => {
   const logger = {
-    log: sinon.fake(),
+    log: fake(),
   };
 
-  sinon.stub(process, 'env').value({
+  stub(process, 'env').value({
     OVSX_PAT: 'abc123',
   });
 
-  const verifyOvsxAuth = require('../lib/verify-ovsx-auth');
+  const { verifyOvsxAuth } = await import('../lib/verify-ovsx-auth.js');
 
   await t.throwsAsync(() => verifyOvsxAuth(logger), {
     instanceOf: SemanticReleaseError,

package/test/verify-pkg.test.js

@@ -1,7 +1,10 @@
-const sinon = require('sinon');
-const test = require('ava');
-const proxyquire = require('proxyquire');
-const SemanticReleaseError = require('@semantic-release/error');
+import avaTest from 'ava';
+import SemanticReleaseError from '@semantic-release/error';
+import { stub } from 'sinon';
+import esmock from 'esmock';
+
+// Run tests serially to avoid env pollution
+const test = avaTest.serial;
 
 const cwd = process.cwd();
 
@@ -9,12 +12,10 @@ 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),
-    },
-    'fs-extra': {
-      readJson: sinon.stub().returns({
+  const { verifyPkg } = await esmock('../lib/verify-pkg.js', {
+    'fs-extra/esm': {
+      pathExists: stub().resolves(true),
+      readJson: stub().resolves({
         name,
         publisher,
       }),
@@ -28,12 +29,10 @@ 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),
-    },
-    'fs-extra': {
-      readJson: sinon.stub().returns({
+  const { verifyPkg } = await esmock('../lib/verify-pkg.js', {
+    'fs-extra/esm': {
+      pathExists: stub().resolves(false),
+      readJson: stub().resolves({
         name,
         publisher,
       }),
@@ -49,14 +48,12 @@ test('package.json is not found', 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),
-    },
-    'fs-extra': {
-      readJson: sinon.stub().returns({
-        publisher,
+  const { verifyPkg } = await esmock('../lib/verify-pkg.js', {
+    'fs-extra/esm': {
+      pathExists: stub().resolves(true),
+      readJson: stub().resolves({
         name,
+        publisher,
       }),
     },
   });
@@ -65,12 +62,10 @@ test('package is valid', async (t) => {
 });
 
 test('package is invalid', async (t) => {
-  const verifyPkg = proxyquire('../lib/verify-pkg', {
-    fs: {
-      existsSync: sinon.stub().returns(true),
-    },
-    'fs-extra': {
-      readJson: sinon.stub().rejects(),
+  const { verifyPkg } = await esmock('../lib/verify-pkg.js', {
+    'fs-extra/esm': {
+      pathExists: stub().resolves(true),
+      readJson: stub().rejects(),
     },
   });
 
@@ -82,12 +77,10 @@ test('package is invalid', async (t) => {
 
 test('package is missing name', async (t) => {
   const publisher = 'tester';
-  const verifyPkg = proxyquire('../lib/verify-pkg', {
-    fs: {
-      existsSync: sinon.stub().returns(true),
-    },
-    'fs-extra': {
-      readJson: sinon.stub().returns({
+  const { verifyPkg } = await esmock('../lib/verify-pkg.js', {
+    'fs-extra/esm': {
+      pathExists: stub().resolves(true),
+      readJson: stub().resolves({
         publisher,
       }),
     },
@@ -101,12 +94,10 @@ test('package is missing name', async (t) => {
 
 test('package is missing publisher', async (t) => {
   const name = 'test';
-  const verifyPkg = proxyquire('../lib/verify-pkg', {
-    fs: {
-      existsSync: sinon.stub().returns(true),
-    },
-    'fs-extra': {
-      readJson: sinon.stub().returns({
+  const { verifyPkg } = await esmock('../lib/verify-pkg.js', {
+    'fs-extra/esm': {
+      pathExists: stub().resolves(true),
+      readJson: stub().resolves({
         name,
       }),
     },

package/test/verify-target.test.js

@@ -1,37 +1,40 @@
-const sinon = require('sinon');
-const test = require('ava');
-const proxyquire = require('proxyquire');
-const SemanticReleaseError = require('@semantic-release/error');
+import SemanticReleaseError from '@semantic-release/error';
+import avaTest from 'ava';
+import esmock from 'esmock';
+import { stub } from 'sinon';
+
+// Run tests serially to avoid env pollution
+const test = avaTest.serial;
 
 test('VSCE_TARGET is not set', async (t) => {
-  const vscePackage = sinon.stub().returns({
+  const vscePackage = stub().returns({
     Targets: new Map(),
   });
-  const verifyTarget = proxyquire('../lib/verify-target', {
-    'vsce/out/package': vscePackage,
+  const { verifyTarget } = await esmock('../lib/verify-target.js', {
+    '@vscode/vsce/out/package.js': vscePackage,
   });
 
   await t.notThrowsAsync(() => verifyTarget());
 });
 
 test('VSCE_TARGET is valid', async (t) => {
-  sinon.stub(process, 'env').value({
+  stub(process, 'env').value({
     VSCE_TARGET: 'linux-x64',
   });
 
-  const verifyTarget = require('../lib/verify-target');
+  const { verifyTarget } = await import('../lib/verify-target.js');
 
   await t.notThrowsAsync(() => verifyTarget());
 });
 
 test('VSCE_TARGET is empty', async (t) => {
-  const vscePackage = sinon.stub().returns({
+  const vscePackage = stub().returns({
     Targets: new Map(),
   });
-  const verifyTarget = proxyquire('../lib/verify-target', {
-    'vsce/out/package': vscePackage,
+  const { verifyTarget } = await esmock('../lib/verify-target.js', {
+    '@vscode/vsce/out/package.js': vscePackage,
   });
-  sinon.stub(process, 'env').value({
+  stub(process, 'env').value({
     VSCE_TARGET: '',
   });
 
@@ -43,10 +46,10 @@ test('VSCE_TARGET is empty', async (t) => {
 });
 
 test('VSCE_TARGET is unsupported', async (t) => {
-  sinon.stub(process, 'env').value({
+  stub(process, 'env').value({
     VSCE_TARGET: 'whatever-x64',
   });
-  const verifyTarget = require('../lib/verify-target');
+  const { verifyTarget } = await import('../lib/verify-target.js');
 
   await t.throwsAsync(() => verifyTarget(), {
     instanceOf: SemanticReleaseError,
@@ -55,11 +58,11 @@ test('VSCE_TARGET is unsupported', async (t) => {
 });
 
 test('VSCE_TARGET is universal', async (t) => {
-  sinon.stub(process, 'env').value({
+  stub(process, 'env').value({
     VSCE_TARGET: 'universal',
   });
 
-  const verifyTarget = require('../lib/verify-target');
+  const { verifyTarget } = await import('../lib/verify-target.js');
 
   await t.notThrowsAsync(() => verifyTarget());
 });