Jest/SuperTest 如何在一组承诺中正确预期 Socket Hangup？

Question

I have a test that says "After approx X concurrent connections, I should see socket hangups since my service will stop answering someone hammering me."

This works pretty well after a lot of painful trial and error, but because I am using await Promise.all(myrequests) the first time I see a hangup it throws a socket hang up exception.

This works, but causes some error messages, since my routine for hanging up does some debug logging, and the test is over at this point.

What's the best way to say: "wait for all of these, even when they throw errors?"

My jest/supertest problem block looks something like:

 //Send enough concurrent connections to trip the dropout
 for(var i = 0;MAX_CONCURRENT_CONNECTIONS+5;i++) 
    {
       requests.push(request(app).get('/'))   
    }
    //wait for all the connections to resolve    
    const t = async () => {          
       await Promise.all(requests);                    
    };
    //and make sure some drop off
    expect(t).toThrow("socket hang up"); //this also doesn't match the error string right but that is because I'm not as experienced in this sort of thing as I'd like!

    //however after this, the test ends, and my back end logging causes problems since the test is over!

What's the best way to still wait for all promises in requests even when one throws on await Promise.all(requests) ?

I can do the following ugly bit of code, but I'm looking for the right way to write this:)

        let gotConnReset = false
        try
        {
           await Promise.all(requests);                                    
        }
        catch(err)
        {
            if(err.message == "socket hang up")
            {
                gotConnReset = true;
            }            
        }
        assert(gotConnReset === true);
        //wait for all the other requests so that Jest doesn't yell at us!
        await Promise.allSettled(requests); 

Answer 1

I don't know that Jest has something to help but there's Promise.allSettled which will wait for all promises to fulfill or reject, returning an array of all results. The rejected promises will have a .reason attached.

The main difference is that Jest will be matching error objects rather than using the thrown error matchers so some of the error specific functionality is not there.

test('allSettled rejects', async () => {
  class Wat extends Error {}
  const resError = new Wat('Nope')
  resError.code = 'NO'
  const res = await Promise.allSettled([
    Promise.resolve(1),
    Promise.reject(resError),
    Promise.resolve(3),
  ])
  expect(res).toEqual(
    expect.arrayContaining([
      { status: 'rejected', reason: new Error('Nope') },
    ])
  )
})

  ✓ allSettled rejects (2 ms)

If you want to avoid the "loose" matching of the example above which passes with any Error object if the message matches, it might need something like jest-matcher-specific-error or to expect.extend an error matcher

The results can use filter / map or reduce to test rejections directly.

(await Promise.allSettled())
  .filter(o => o.status === 'rejected')
  .map(o => o.reason)`