semantic-release-vsce 6.0.0 → 6.0.1

package/test/verify-pkg.test.js

@@ -1,110 +0,0 @@
-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();
-
-test('package.json is found', async (t) => {
-  const name = 'test';
-  const publisher = 'tester';
-
-  const { verifyPkg } = await esmock('../lib/verify-pkg.js', {
-    'fs-extra/esm': {
-      pathExists: stub().resolves(true),
-      readJson: stub().resolves({
-        name,
-        publisher,
-      }),
-    },
-  });
-
-  await t.notThrowsAsync(() => verifyPkg(cwd));
-});
-
-test('package.json is not found', async (t) => {
-  const name = 'test';
-  const publisher = 'tester';
-
-  const { verifyPkg } = await esmock('../lib/verify-pkg.js', {
-    'fs-extra/esm': {
-      pathExists: stub().resolves(false),
-      readJson: stub().resolves({
-        name,
-        publisher,
-      }),
-    },
-  });
-
-  await t.throwsAsync(() => verifyPkg(cwd), {
-    instanceOf: SemanticReleaseError,
-    code: 'ENOPKG',
-  });
-});
-
-test('package is valid', async (t) => {
-  const name = 'test';
-  const publisher = 'tester';
-  const { verifyPkg } = await esmock('../lib/verify-pkg.js', {
-    'fs-extra/esm': {
-      pathExists: stub().resolves(true),
-      readJson: stub().resolves({
-        name,
-        publisher,
-      }),
-    },
-  });
-
-  await t.notThrowsAsync(() => verifyPkg(cwd));
-});
-
-test('package is invalid', async (t) => {
-  const { verifyPkg } = await esmock('../lib/verify-pkg.js', {
-    'fs-extra/esm': {
-      pathExists: stub().resolves(true),
-      readJson: stub().rejects(),
-    },
-  });
-
-  await t.throwsAsync(() => verifyPkg(cwd), {
-    instanceOf: SemanticReleaseError,
-    code: 'EINVALIDPKG',
-  });
-});
-
-test('package is missing name', async (t) => {
-  const publisher = 'tester';
-  const { verifyPkg } = await esmock('../lib/verify-pkg.js', {
-    'fs-extra/esm': {
-      pathExists: stub().resolves(true),
-      readJson: stub().resolves({
-        publisher,
-      }),
-    },
-  });
-
-  await t.throwsAsync(() => verifyPkg(cwd), {
-    instanceOf: SemanticReleaseError,
-    code: 'ENOPKGNAME',
-  });
-});
-
-test('package is missing publisher', async (t) => {
-  const name = 'test';
-  const { verifyPkg } = await esmock('../lib/verify-pkg.js', {
-    'fs-extra/esm': {
-      pathExists: stub().resolves(true),
-      readJson: stub().resolves({
-        name,
-      }),
-    },
-  });
-
-  await t.throwsAsync(() => verifyPkg(cwd), {
-    instanceOf: SemanticReleaseError,
-    code: 'ENOPUBLISHER',
-  });
-});

package/test/verify-target.test.js

@@ -1,68 +0,0 @@
-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 = stub().returns({
-    Targets: new Map(),
-  });
-  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) => {
-  stub(process, 'env').value({
-    VSCE_TARGET: 'linux-x64',
-  });
-
-  const { verifyTarget } = await import('../lib/verify-target.js');
-
-  await t.notThrowsAsync(() => verifyTarget());
-});
-
-test('VSCE_TARGET is empty', async (t) => {
-  const vscePackage = stub().returns({
-    Targets: new Map(),
-  });
-  const { verifyTarget } = await esmock('../lib/verify-target.js', {
-    '@vscode/vsce/out/package.js': vscePackage,
-  });
-  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) => {
-  stub(process, 'env').value({
-    VSCE_TARGET: 'whatever-x64',
-  });
-  const { verifyTarget } = await import('../lib/verify-target.js');
-
-  await t.throwsAsync(() => verifyTarget(), {
-    instanceOf: SemanticReleaseError,
-    code: 'EUNSUPPORTEDVSCETARGET',
-  });
-});
-
-test('VSCE_TARGET is universal', async (t) => {
-  stub(process, 'env').value({
-    VSCE_TARGET: 'universal',
-  });
-
-  const { verifyTarget } = await import('../lib/verify-target.js');
-
-  await t.notThrowsAsync(() => verifyTarget());
-});

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

@@ -1,168 +0,0 @@
-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 logger = {
-  log: fake(),
-};
-const cwd = process.cwd();
-
-test('VSCE_PAT is set', async (t) => {
-  stub(process, 'env').value({
-    VSCE_PAT: 'abc123',
-  });
-
-  const { verifyVsceAuth } = await esmock('../lib/verify-vsce-auth.js', {
-    execa: {
-      execa: stub()
-        .withArgs('vsce', ['verify-pat'], { preferLocal: true, cwd })
-        .resolves(),
-    },
-  });
-
-  await t.notThrowsAsync(() => verifyVsceAuth(logger));
-});
-
-test('VSCE_AZURE_CREDENTIAL is set to true', async (t) => {
-  stub(process, 'env').value({
-    VSCE_AZURE_CREDENTIAL: 'true',
-  });
-
-  const { verifyVsceAuth } = await esmock('../lib/verify-vsce-auth.js', {
-    execa: {
-      execa: stub()
-        .withArgs('vsce', ['verify-pat', '--azure-credential'], {
-          preferLocal: true,
-          cwd,
-        })
-        .resolves(),
-    },
-  });
-
-  await t.notThrowsAsync(() => verifyVsceAuth(logger));
-});
-
-test('VSCE_AZURE_CREDENTIAL is set to 1', async (t) => {
-  stub(process, 'env').value({
-    VSCE_AZURE_CREDENTIAL: '1',
-  });
-
-  const { verifyVsceAuth } = await esmock('../lib/verify-vsce-auth.js', {
-    execa: {
-      execa: stub()
-        .withArgs('vsce', ['verify-pat', '--azure-credential'], {
-          preferLocal: true,
-          cwd,
-        })
-        .resolves(),
-    },
-  });
-
-  await t.notThrowsAsync(() => verifyVsceAuth(logger));
-});
-
-test('VSCE_AZURE_CREDENTIAL is set to false', async (t) => {
-  stub(process, 'env').value({
-    VSCE_AZURE_CREDENTIAL: 'false',
-  });
-
-  const { verifyVsceAuth } = await import('../lib/verify-vsce-auth.js');
-
-  await t.throwsAsync(() => verifyVsceAuth(logger), {
-    instanceOf: SemanticReleaseError,
-    code: 'EVSCEAUTHNOTPROVIDED',
-  });
-});
-
-test('VSCE_PAT is valid', async (t) => {
-  stub(process, 'env').value({
-    VSCE_PAT: 'abc123',
-  });
-
-  const { verifyVsceAuth } = await esmock('../lib/verify-vsce-auth.js', {
-    execa: {
-      execa: stub()
-        .withArgs('vsce', ['verify-pat'], { preferLocal: true, cwd })
-        .resolves(),
-    },
-  });
-
-  await t.notThrowsAsync(() => verifyVsceAuth(logger));
-});
-
-test('VSCE_PAT is valid and VSCE_AZURE_CREDENTIAL=false', async (t) => {
-  stub(process, 'env').value({
-    VSCE_PAT: 'abc123',
-    VSCE_AZURE_CREDENTIAL: 'false',
-  });
-
-  const { verifyVsceAuth } = await esmock('../lib/verify-vsce-auth.js', {
-    execa: {
-      execa: stub()
-        .withArgs('vsce', ['verify-pat'], { preferLocal: true, cwd })
-        .resolves(),
-    },
-  });
-
-  await t.notThrowsAsync(() => verifyVsceAuth(logger));
-});
-
-test('Neither VSCE_PAT or VSCE_AZURE_CREDENTIAL are set', async (t) => {
-  const logger = {
-    log: fake(),
-  };
-
-  stub(process, 'env').value({
-    VSCE_PAT: '',
-  });
-
-  const { verifyVsceAuth } = await import('../lib/verify-vsce-auth.js');
-
-  await t.throwsAsync(() => verifyVsceAuth(logger), {
-    instanceOf: SemanticReleaseError,
-    code: 'EVSCEAUTHNOTPROVIDED',
-  });
-});
-
-test('VSCE_PAT is invalid but not empty', async (t) => {
-  stub(process, 'env').value({
-    VSCE_PAT: 'abc123',
-  });
-
-  const { verifyVsceAuth } = await esmock('../lib/verify-vsce-auth.js', {
-    execa: {
-      execa: stub()
-        .withArgs('vsce', ['verify-pat'], { preferLocal: true, cwd })
-        .rejects(),
-    },
-  });
-
-  await t.throwsAsync(() => verifyVsceAuth(logger), {
-    instanceOf: SemanticReleaseError,
-    code: 'EINVALIDVSCEPAT',
-  });
-});
-
-test('Both VSCE_PAT and VSCE_AZURE_CREDENTIAL are set', async (t) => {
-  stub(process, 'env').value({
-    VSCE_PAT: 'abc123',
-    VSCE_AZURE_CREDENTIAL: 'true',
-  });
-
-  const { verifyVsceAuth } = await esmock('../lib/verify-vsce-auth.js', {
-    execa: {
-      execa: stub()
-        .withArgs('vsce', ['verify-pat'], { preferLocal: true, cwd })
-        .rejects(),
-    },
-  });
-
-  await t.throwsAsync(() => verifyVsceAuth(logger), {
-    instanceOf: SemanticReleaseError,
-    code: 'EVSCEDUPLICATEAUTHPROVIDED',
-  });
-});

package/test/verify.test.js

@@ -1,243 +0,0 @@
-import SemanticReleaseError from '@semantic-release/error';
-import test from 'ava';
-import { fake, stub } from 'sinon';
-import esmock from 'esmock';
-
-const logger = {
-  log: fake(),
-};
-const cwd = process.cwd();
-
-test('resolves', async (t) => {
-  const { verify } = await esmock('../lib/verify.js', {
-    '../lib/verify-pkg.js': {
-      verifyPkg: stub().resolves(),
-    },
-    '../lib/verify-target.js': {
-      verifyTarget: stub().resolves(),
-    },
-    '../lib/verify-vsce-auth.js': {
-      verifyVsceAuth: stub().resolves(),
-    },
-    '../lib/verify-ovsx-auth.js': {
-      verifyOvsxAuth: stub().resolves(),
-    },
-    '../lib/utils.js': {
-      isVscePublishEnabled: stub().returns(true),
-      isOvsxPublishEnabled: stub().returns(true),
-    },
-  });
-
-  await t.notThrowsAsync(() => verify({}, { logger, cwd }));
-});
-
-test('rejects with verify-pkg', async (t) => {
-  const { verify } = await esmock('../lib/verify.js', {
-    '../lib/verify-pkg.js': {
-      verifyPkg: stub().rejects(),
-    },
-    '../lib/verify-target.js': {
-      verifyTarget: stub().resolves(),
-    },
-    '../lib/verify-vsce-auth.js': {
-      verifyVsceAuth: stub().resolves(),
-    },
-    '../lib/verify-ovsx-auth.js': {
-      verifyOvsxAuth: stub().resolves(),
-    },
-  });
-
-  await t.throwsAsync(() => verify({}, { logger, cwd }));
-});
-
-test('rejects with verify-target', async (t) => {
-  const { verify } = await esmock('../lib/verify.js', {
-    '../lib/verify-pkg.js': {
-      verifyPkg: stub().resolves(),
-    },
-    '../lib/verify-target.js': {
-      verifyTarget: stub().rejects(),
-    },
-    '../lib/verify-vsce-auth.js': {
-      verifyVsceAuth: stub().resolves(),
-    },
-    '../lib/verify-ovsx-auth.js': {
-      verifyOvsxAuth: stub().resolves(),
-    },
-  });
-
-  await t.throwsAsync(() => verify({}, { logger, cwd }));
-});
-
-test('rejects with verify-auth', async (t) => {
-  const { verify } = await esmock('../lib/verify.js', {
-    '../lib/verify-pkg.js': {
-      verifyPkg: stub().resolves(),
-    },
-    '../lib/verify-target.js': {
-      verifyTarget: stub().resolves(),
-    },
-    '../lib/verify-vsce-auth.js': {
-      verifyVsceAuth: stub().rejects(),
-    },
-    '../lib/verify-ovsx-auth.js': {
-      verifyOvsxAuth: stub().resolves(),
-    },
-  });
-
-  await t.throwsAsync(() => verify({}, { logger, cwd }));
-});
-
-test('rejects with verify-ovsx-auth', async (t) => {
-  const { verify } = await esmock('../lib/verify.js', {
-    '../lib/verify-pkg.js': {
-      verifyPkg: stub().resolves(),
-    },
-    '../lib/verify-target.js': {
-      verifyTarget: stub().resolves(),
-    },
-    '../lib/verify-vsce-auth.js': {
-      verifyVsceAuth: stub().resolves(),
-    },
-    '../lib/verify-ovsx-auth.js': {
-      verifyOvsxAuth: stub().rejects(),
-    },
-  });
-
-  await t.throwsAsync(() => verify({}, { logger, cwd }));
-});
-
-test('it does not verify the auth tokens if publishing is disabled', async (t) => {
-  const stubs = {
-    verifyPkgStub: stub().resolves(),
-    verifyTargetStub: stub().resolves(),
-    verifyVsceAuthStub: stub().resolves(),
-    verifyOvsxAuthStub: stub().resolves(),
-  };
-  const { verify } = await esmock('../lib/verify.js', {
-    '../lib/verify-pkg.js': {
-      verifyPkg: stubs.verifyPkgStub,
-    },
-    '../lib/verify-target.js': {
-      verifyTarget: stubs.verifyTargetStub,
-    },
-    '../lib/verify-vsce-auth.js': {
-      verifyVsceAuth: stubs.verifyVsceAuthStub,
-    },
-    '../lib/verify-ovsx-auth.js': {
-      verifyOvsxAuth: stubs.verifyOvsxAuthStub,
-    },
-  });
-
-  await verify({ publish: false }, { logger, cwd });
-
-  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: stub().resolves(),
-    verifyTargetStub: stub().resolves(),
-    verifyVsceAuthStub: stub().resolves(),
-    verifyOvsxAuthStub: stub().resolves(),
-    utilsStub: {
-      isVscePublishEnabled: stub().returns(false),
-      isOvsxPublishEnabled: stub().returns(false),
-    },
-  };
-  const { verify } = await esmock('../lib/verify.js', {
-    '../lib/verify-pkg.js': {
-      verifyPkg: stubs.verifyPkgStub,
-    },
-    '../lib/verify-target.js': {
-      verifyTarget: stubs.verifyTargetStub,
-    },
-    '../lib/verify-vsce-auth.js': {
-      verifyVsceAuth: stubs.verifyVsceAuthStub,
-    },
-    '../lib/verify-ovsx-auth.js': {
-      verifyOvsxAuth: stubs.verifyOvsxAuthStub,
-    },
-    '../lib/utils.js': 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: stub().resolves(),
-    verifyTargetStub: stub().resolves(),
-    verifyVsceAuthStub: stub().resolves(),
-    verifyOvsxAuthStub: stub().resolves(),
-    utilsStub: {
-      isVscePublishEnabled: stub().returns(true),
-      isOvsxPublishEnabled: stub().returns(false),
-    },
-    logger: {
-      log: fake(),
-    },
-  };
-  const { verify } = await esmock('../lib/verify.js', {
-    '../lib/verify-pkg.js': {
-      verifyPkg: stubs.verifyPkgStub,
-    },
-    '../lib/verify-target.js': {
-      verifyTarget: stubs.verifyTargetStub,
-    },
-    '../lib/verify-vsce-auth.js': {
-      verifyVsceAuth: stubs.verifyVsceAuthStub,
-    },
-    '../lib/verify-ovsx-auth.js': {
-      verifyOvsxAuth: stubs.verifyOvsxAuthStub,
-    },
-    '../lib/utils.js': 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: stub().resolves(),
-    verifyTargetStub: stub().resolves(),
-    verifyVsceAuthStub: stub().resolves(),
-    verifyOvsxAuthStub: stub().resolves(),
-    utilsStub: {
-      isVscePublishEnabled: stub().returns(false),
-      isOvsxPublishEnabled: stub().returns(true),
-    },
-    logger: {
-      log: fake(),
-    },
-  };
-  const { verify } = await esmock('../lib/verify.js', {
-    '../lib/verify-pkg.js': {
-      verifyPkg: stubs.verifyPkgStub,
-    },
-    '../lib/verify-target.js': {
-      verifyTarget: stubs.verifyTargetStub,
-    },
-    '../lib/verify-vsce-auth.js': {
-      verifyVsceAuth: stubs.verifyVsceAuthStub,
-    },
-    '../lib/verify-ovsx-auth.js': {
-      verifyOvsxAuth: stubs.verifyOvsxAuthStub,
-    },
-    '../lib/utils.js': stubs.utilsStub,
-  });
-
-  await verify({}, { logger: stubs.logger, cwd });
-  t.true(stubs.verifyVsceAuthStub.notCalled);
-  t.true(stubs.verifyOvsxAuthStub.calledOnce);
-  t.true(stubs.logger.log.calledOnce);
-});