Merge branch 'heroku:main' into maarten/heroku-ps-exec-elixir-iex

Author: tarzan

test/unit/commands/access/update.unit.test.ts

@@ -70,16 +70,14 @@ describe('heroku access:update', function () {
     })
     it('returns an error when passing permissions', async function () {
       personalApp()
-      await runCommand(Cmd, [
+      const {error} = await runCommand(Cmd, [
         '--app',
         'myapp',
         '--permissions',
         'view,deploy',
         'gandalf@heroku.com',
-      ]).catch(error => {
-        const {message} = error as {message: string}
-        expect(ansis.strip(message)).to.contain('Error: cannot update permissions. The app ⬢ myapp is not owned by a team')
-      })
+      ])
+      expect(ansis.strip(error?.message ?? '')).to.contain('Error: cannot update permissions. The app ⬢ myapp is not owned by a team')
     })
   })
 })

test/unit/commands/accounts/add.unit.test.ts

@@ -104,11 +104,8 @@ describe('accounts:add', function () {
 
       listStub.resolves([{name: 'testAccountName', username: 'testEmail'}])
 
-      try {
-        await runCommand(Cmd, ['testAccountName'])
-      } catch (error: unknown) {
-        expect((error as Error).message).to.contain('testAccountName already exists')
-      }
+      const {error} = await runCommand(Cmd, ['testAccountName'])
+      expect(error?.message).to.contain('testAccountName already exists')
     })
 
     it('should error if the email already has an alias', async function () {
@@ -121,11 +118,8 @@ describe('accounts:add', function () {
 
       listStub.resolves([{name: 'existingAlias', username: 'testEmail'}])
 
-      try {
-        await runCommand(Cmd, ['newAlias'])
-      } catch (error: unknown) {
-        expect((error as Error).message).to.contain('testEmail already has an alias: existingAlias')
-      }
+      const {error} = await runCommand(Cmd, ['newAlias'])
+      expect(error?.message).to.equal('Account testEmail already has an alias of existingAlias.')
     })
   })
 })

test/unit/commands/accounts/current.unit.test.ts

@@ -25,10 +25,8 @@ describe('accounts:current', function () {
 
   it('should print an error message if no account is found', async function () {
     currentStub.resolves(null)
-    await runCommand(Cmd, [])
-      .catch((error: Error) => {
-        const expected = 'You haven\'t set an account. Run heroku accounts:add <account-name> to add an account to your cache or heroku accounts:set <account-name> to set the current account.'
-        expect(ansis.strip(error.message)).to.equal(expected)
-      })
+    const {error} = await runCommand(Cmd, [])
+    expect(ansis.strip(error?.message ?? '')).to.equal(`You haven't set an account.\n
+      Run heroku accounts:add <account-name> to add an account to your cache or heroku accounts:set <account-name> to set the current account.`)
   })
 })

test/unit/commands/accounts/index.unit.test.ts

@@ -27,9 +27,7 @@ describe('accounts', function () {
 
   it('should print an error message if no accounts are found', async function () {
     listStub.resolves([])
-    await runCommand(Cmd, [])
-      .catch((error: Error) => {
-        expect(error.message).to.contain('You don\'t have any accounts in your cache.')
-      })
+    const {error} = await runCommand(Cmd, [])
+    expect(error?.message).to.contain('You don\'t have any accounts in your cache.')
   })
 })

test/unit/commands/accounts/remove.unit.test.ts

@@ -32,27 +32,21 @@ describe('accounts:remove', function () {
   it('should return an error if the selected account name is not included in the account list', async function () {
     currentStub.resolves('test-account')
     listStub.resolves([{name: 'test-account', username: 'user1'}, {name: 'test-account-2', username: 'user2'}])
-    await runCommand(Cmd, ['test-account-3'])
-      .catch((error: Error) => {
-        expect(error.message).to.contain('test-account-3 doesn\'t exist in your accounts cache.')
-      })
+    const {error} = await runCommand(Cmd, ['test-account-3'])
+    expect(error?.message).to.contain('test-account-3 doesn\'t exist in your accounts cache.')
   })
 
   it('should return an error if the selected account name is the current account', async function () {
     currentStub.resolves('test-account')
     listStub.resolves([{name: 'test-account', username: 'user1'}, {name: 'test-account-2', username: 'user2'}])
-    await runCommand(Cmd, ['test-account'])
-      .catch((error: Error) => {
-        expect(ansis.strip(error.message)).to.equal('test-account is the current account. To log out, run heroku logout.')
-      })
+    const {error} = await runCommand(Cmd, ['test-account'])
+    expect(ansis.strip(error?.message ?? '')).to.equal('test-account is the current account. To log out, run  $ heroku logout .')
   })
 
   it('should return an error if the selected account is the current account (aliased)', async function () {
     currentStub.resolves('user1@example.com')
     listStub.resolves([{name: 'test-account', username: 'user1@example.com'}, {name: 'test-account-2', username: 'user2@example.com'}])
-    await runCommand(Cmd, ['test-account'])
-      .catch((error: Error) => {
-        expect(ansis.strip(error.message)).to.equal('test-account is the current account. To log out, run heroku logout.')
-      })
+    const {error} = await runCommand(Cmd, ['test-account'])
+    expect(ansis.strip(error?.message ?? '')).to.equal('test-account is the current account. To log out, run  $ heroku logout .')
   })
 })

test/unit/commands/addons/create.unit.test.ts

@@ -58,17 +58,15 @@ describe('addons:create', function () {
   })
   context('calling addons:create without a plan', function () {
     it('errors out with usage', async function () {
-      return runCommand(Cmd, [
+      const {error} = await runCommand(Cmd, [
         '--app',
         'myapp',
         '--name',
         'foobar',
       ])
-        .catch((error: unknown) => {
-          expect((error as Error).message).to.equal('Missing 1 required arg:\n'
-            + 'service:plan  unique identifier or unique name of the add-on service plan\n'
-            + 'See more help with --help')
-        })
+      expect(error?.message).to.equal('Missing 1 required arg:\n'
+        + 'service:plan  unique identifier or unique name of the add-on service plan\n'
+        + 'See more help with --help')
     })
   })
   context('creating a db', function () {
@@ -262,21 +260,19 @@ describe('addons:create', function () {
         deprovisionedAddon.state = 'deprovisioned'
         api.get('/apps/myapp/addons/postgresql-swiftly-123')
           .reply(200, deprovisionedAddon)
-        try {
-          return await runCommand(Cmd, [
-            '--app',
-            'myapp',
-            '--as',
-            'mydb',
-            '--wait',
-            'heroku-postgresql:standard-0',
-            '--',
-            '--wait',
-          ])
-        } catch {
-          expect(notifyStub.called).to.equal(true)
-          expect(notifyStub.calledOnce).to.equal(true)
-        }
+        const {error} = await runCommand(Cmd, [
+          '--app',
+          'myapp',
+          '--as',
+          'mydb',
+          '--wait',
+          'heroku-postgresql:standard-0',
+          '--',
+          '--wait',
+        ])
+        expect(error?.message).to.equal('The add-on was unable to be created, with status deprovisioned')
+        expect(notifyStub.called).to.equal(true)
+        expect(notifyStub.calledOnce).to.equal(true)
       })
     })
     context('when add-on provision errors', function () {
@@ -299,13 +295,13 @@ describe('addons:create', function () {
     })
   })
   context('creating a db requiring confirmation', function () {
-    it('aborts if confirmation does not match', function () {
+    it('aborts if confirmation does not match', async function () {
       api.post('/apps/myapp/addons', {
         attachment: {name: 'mydb'}, config: {follow: 'otherdb', foo: true, rollback: true}, confirm: 'not-my-app', plan: {name: 'heroku-postgresql:standard-0'},
       })
         .reply(423, {id: 'confirmation_required', message: 'This add-on is not automatically networked with this Private Space. '}, {'X-Confirmation-Required': 'myapp-confirm'})
 
-      return runCommand(Cmd, [
+      const {error} = await runCommand(Cmd, [
         '--app',
         'myapp',
         '--as',
@@ -319,9 +315,7 @@ describe('addons:create', function () {
         'otherdb',
         '--foo',
       ])
-        .catch(error => {
-          expect(ansis.strip(error.message)).to.equal('Confirmation not-my-app did not match myapp. Aborted.')
-        })
+      expect(ansis.strip(error?.message ?? '')).to.equal('Confirmation not-my-app did not match myapp. Aborted.')
     })
 
     it('succeeds if confirmation does match', async function () {

test/unit/commands/addons/rename.unit.test.ts

@@ -31,8 +31,8 @@ describe('addons:rename', function () {
       nock('https://api.heroku.com')
         .get('/addons/not-an-addon')
         .reply(404, {id: 'not_found', message: "Couldn't find that add-on.", resource: 'addon'})
-      await runCommand(Cmd, ['not-an-addon', 'cache-redis'])
-        .catch(error => expect(error.message).to.contain("Couldn't find that add-on."))
+      const {error} = await runCommand(Cmd, ['not-an-addon', 'cache-redis'])
+      expect(error?.message).to.contain("Couldn't find that add-on.")
     })
   })
 })

test/unit/commands/addons/upgrade.unit.test.ts

@@ -136,17 +136,12 @@ describe('addons:upgrade', function () {
   })
 
   it('errors with no plan', async function () {
-    try {
-      await runCommand(Cmd, [
-        '--app',
-        'myapp',
-        'heroku-redis',
-      ])
-    } catch (error) {
-      if (error instanceof Error) {
-        expect(error.message).to.contain('Error: No plan specified')
-      }
-    }
+    const {error} = await runCommand(Cmd, [
+      '--app',
+      'myapp',
+      'heroku-redis',
+    ])
+    expect(error?.message).to.contain('Error: No plan specified')
   })
 
   it('errors with invalid plan', async function () {
@@ -169,46 +164,31 @@ describe('addons:upgrade', function () {
       .patch('/apps/myapp/addons/db1-swiftly-123', {plan: {name: 'heroku-db1:invalid'}})
       .reply(422, {message: 'Couldn\'t find either the add-on service or the add-on plan of "heroku-db1:invalid".'})
 
-    try {
-      await runCommand(Cmd, [
-        '--app',
-        'myapp',
-        'heroku-db1:invalid',
-      ])
-    } catch (error) {
-      if (error instanceof Error) {
-        expect(ansis.strip(error.message)).to.equal('Couldn\'t find either the add-on service or the add-on plan of "heroku-db1:invalid".\n\nHere are the available plans for heroku-db1:\nheroku-db1:free\nheroku-db1:basic\nheroku-db1:premium-0\n\nSee more plan information with heroku addons:plans heroku-db1\n\nhttps://devcenter.heroku.com/articles/managing-add-ons')
-      }
-    }
+    const {error} = await runCommand(Cmd, [
+      '--app',
+      'myapp',
+      'heroku-db1:invalid',
+    ])
+    expect(ansis.strip(error?.message ?? '')).to.equal('Couldn\'t find either the add-on service or the add-on plan of "heroku-db1:invalid".\n\nHere are the available plans for heroku-db1:\nheroku-db1:free\nheroku-db1:basic\nheroku-db1:premium-0\n\nSee more plan information with heroku addons:plans heroku-db1\n\nhttps://devcenter.heroku.com/articles/managing-add-ons')
   })
 
   it('displays an error when multiple matches exist', async function () {
     api.post('/actions/addons/resolve', {addon: 'heroku-postgresql', app: 'myapp'})
       .reply(422, {id: 'multiple_matches', message: 'Multiple matches'})
-    try {
-      await runCommand(Cmd, [
-        '--app',
-        'myapp',
-        'heroku-postgresql:hobby',
-      ])
-    } catch (error) {
-      if (error instanceof Error) {
-        expect(error.message).to.contain('Multiple add-ons match')
-      }
-    }
+    const {error} = await runCommand(Cmd, [
+      '--app',
+      'myapp',
+      'heroku-postgresql:hobby',
+    ])
+    expect(error?.message).to.contain('Multiple add-ons match')
   })
 
   it('handles multiple add-ons', async function () {
     api.post('/actions/addons/resolve', {addon: 'heroku-redis', app: null})
       .reply(200, [{name: 'db1-swiftly-123'}, {name: 'db1-swiftly-456'}])
-    try {
-      await runCommand(Cmd, [
-        'heroku-redis:invalid',
-      ])
-    } catch (error) {
-      if (error instanceof Error) {
-        expect(error.message).to.contain('multiple matching add-ons found')
-      }
-    }
+    const {error} = await runCommand(Cmd, [
+      'heroku-redis:invalid',
+    ])
+    expect(error?.message).to.contain('multiple matching add-ons found')
   })
 })

test/unit/commands/addons/wait.unit.test.ts

@@ -125,12 +125,10 @@ Created www-redis as REDIS_URL
         nock('https://api.heroku.com', {reqheaders: expansionHeaders})
           .get('/apps/acme-inc-www/addons/www-redis')
           .reply(200, deprovisionedAddon)
-        await runCommand(Cmd, ['www-redis'])
-          .catch(error => {
-            expect(error.message).to.equal('The add-on was unable to be created, with status deprovisioned')
-            expect(notifyStub.called).to.be.true
-            expect(notifyStub.calledOnce).to.be.true
-          })
+        const {error} = await runCommand(Cmd, ['www-redis'])
+        expect(error?.message).to.equal('The add-on was unable to be created, with status deprovisioned')
+        expect(notifyStub.called).to.be.true
+        expect(notifyStub.calledOnce).to.be.true
       })
       it('shows that it failed to provision', async function () {
         const notifyStub = sandbox.stub(Cmd, 'notifier')

test/unit/commands/apps/leave.unit.test.ts

@@ -60,16 +60,22 @@ describe('heroku apps:leave', function () {
 
   describe('when the user tries to leave the app', function () {
     it('shows an error if the heroku.delete() operation returns an error', async function () {
-      try {
-        await runCommand(LeaveCommand, [
-          '--app',
-          'myapp',
-        ])
-        apiGetUserAccount.done()
-        apiDeletePersonalAppCollaborator.done()
-      } catch (error) {
-        expect(error).to.be.an.instanceof(Error)
-      }
+      nock.cleanAll()
+
+      const account = nock('https://api.heroku.com')
+        .get('/account')
+        .reply(200, {email: 'gandalf@heroku.com'})
+      const deletion = nock('https://api.heroku.com')
+        .delete(`/apps/myapp/collaborators/${encodeURIComponent('gandalf@heroku.com')}`)
+        .reply(403, {id: 'forbidden', message: 'You cannot leave this app.'})
+
+      const {error} = await runCommand(LeaveCommand, [
+        '--app',
+        'myapp',
+      ])
+      expect(error).to.be.an.instanceof(Error)
+      account.done()
+      deletion.done()
     })
   })
 })