[Pkg-javascript-devel] Bug#1135433: node-pinkie: FTBFS: Error: Timeout of 2000ms exceeded.

[Santiago Vila]

Package: src:node-pinkie
Version: 2.0.4-2
Severity: serious
Tags: ftbfs forky sid

Dear maintainer:

During a rebuild of all packages in unstable, this package failed to build.

Below you will find the last part of the build log (probably the most
relevant part, but not necessarily). If required, the full build log
is available here:

https://people.debian.org/~sanvila/build-logs/202605/

About the archive rebuild: The build was made on virtual machines from AWS,
using sbuild and a reduced chroot with only build-essential packages.

If you cannot reproduce the bug please contact me privately, as I
am willing to provide ssh access to a virtual machine where the bug is
fully reproducible.

If this is really a bug in one of the build-depends, please use
reassign and add an affects on src:node-pinkie, so that this is still
visible in the BTS web page for this package.

Thanks.

--------------------------------------------------------------------------------
[...]
 debian/rules clean
dh clean
   dh_auto_clean --buildsystem=nodejs
	rm -rf ./node_modules/.cache ./.nyc_output
rm ./node_modules/.cache
rm ./node_modules/.cache
   dh_clean
 debian/rules binary
dh binary
   dh_update_autotools_config
   dh_autoreconf
   dh_auto_configure --buildsystem=nodejs
   dh_auto_build --buildsystem=nodejs
No build command found, searching known files
   dh_auto_test --buildsystem=nodejs

[... snipped ...]

            `then` calls `rejectPromise` synchronously
              ✔ via return from a fulfilled promise
              ✔ via return from a rejected promise
            `then` calls `rejectPromise` asynchronously
              ✔ via return from a fulfilled promise
              ✔ via return from a rejected promise
          `r` is `null`
            `then` calls `rejectPromise` synchronously
              ✔ via return from a fulfilled promise
              ✔ via return from a rejected promise
            `then` calls `rejectPromise` asynchronously
              ✔ via return from a fulfilled promise
              ✔ via return from a rejected promise
          `r` is `false`
            `then` calls `rejectPromise` synchronously
              ✔ via return from a fulfilled promise
              ✔ via return from a rejected promise
            `then` calls `rejectPromise` asynchronously
              ✔ via return from a fulfilled promise
              ✔ via return from a rejected promise
          `r` is `0`
            `then` calls `rejectPromise` synchronously
              ✔ via return from a fulfilled promise
              ✔ via return from a rejected promise
            `then` calls `rejectPromise` asynchronously
              ✔ via return from a fulfilled promise
              ✔ via return from a rejected promise
          `r` is an error
            `then` calls `rejectPromise` synchronously
              ✔ via return from a fulfilled promise
              ✔ via return from a rejected promise
            `then` calls `rejectPromise` asynchronously
              ✔ via return from a fulfilled promise
              ✔ via return from a rejected promise
          `r` is an error without a stack
            `then` calls `rejectPromise` synchronously
              ✔ via return from a fulfilled promise
              ✔ via return from a rejected promise
            `then` calls `rejectPromise` asynchronously
              ✔ via return from a fulfilled promise
              ✔ via return from a rejected promise
          `r` is a date
            `then` calls `rejectPromise` synchronously
              ✔ via return from a fulfilled promise
              ✔ via return from a rejected promise
            `then` calls `rejectPromise` asynchronously
              ✔ via return from a fulfilled promise
              ✔ via return from a rejected promise
          `r` is an object
            `then` calls `rejectPromise` synchronously
              ✔ via return from a fulfilled promise
              ✔ via return from a rejected promise
            `then` calls `rejectPromise` asynchronously
              ✔ via return from a fulfilled promise
              ✔ via return from a rejected promise
          `r` is an always-pending thenable
            `then` calls `rejectPromise` synchronously
              ✔ via return from a fulfilled promise
              ✔ via return from a rejected promise
            `then` calls `rejectPromise` asynchronously
              ✔ via return from a fulfilled promise
              ✔ via return from a rejected promise
          `r` is a fulfilled promise
            `then` calls `rejectPromise` synchronously
              ✔ via return from a fulfilled promise
              ✔ via return from a rejected promise
            `then` calls `rejectPromise` asynchronously
              ✔ via return from a fulfilled promise
              ✔ via return from a rejected promise
          `r` is a rejected promise
            `then` calls `rejectPromise` synchronously
              ✔ via return from a fulfilled promise
              ✔ via return from a rejected promise
            `then` calls `rejectPromise` asynchronously
              ✔ via return from a fulfilled promise
              ✔ via return from a rejected promise
        2.3.3.3.3: If both `resolvePromise` and `rejectPromise` are called, or multiple calls to the same argument are made, the first call takes precedence, and any further calls are ignored.
          calling `resolvePromise` then `rejectPromise`, both synchronously
            ✔ via return from a fulfilled promise
            ✔ via return from a rejected promise
          calling `resolvePromise` synchronously then `rejectPromise` asynchronously
            ✔ via return from a fulfilled promise
            ✔ via return from a rejected promise
          calling `resolvePromise` then `rejectPromise`, both asynchronously
            ✔ via return from a fulfilled promise
            ✔ via return from a rejected promise
          calling `resolvePromise` with an asynchronously-fulfilled promise, then calling `rejectPromise`, both synchronously
            ✔ via return from a fulfilled promise (51ms)
            ✔ via return from a rejected promise (50ms)
          calling `resolvePromise` with an asynchronously-rejected promise, then calling `rejectPromise`, both synchronously
            ✔ via return from a fulfilled promise (51ms)
            ✔ via return from a rejected promise (50ms)
          calling `rejectPromise` then `resolvePromise`, both synchronously
            ✔ via return from a fulfilled promise
            ✔ via return from a rejected promise
          calling `rejectPromise` synchronously then `resolvePromise` asynchronously
            ✔ via return from a fulfilled promise
            ✔ via return from a rejected promise
          calling `rejectPromise` then `resolvePromise`, both asynchronously
            ✔ via return from a fulfilled promise
            ✔ via return from a rejected promise
          calling `resolvePromise` twice synchronously
            ✔ via return from a fulfilled promise
            ✔ via return from a rejected promise
          calling `resolvePromise` twice, first synchronously then asynchronously
            ✔ via return from a fulfilled promise
            ✔ via return from a rejected promise
          calling `resolvePromise` twice, both times asynchronously
            ✔ via return from a fulfilled promise
            ✔ via return from a rejected promise
          calling `resolvePromise` with an asynchronously-fulfilled promise, then calling it again, both times synchronously
            ✔ via return from a fulfilled promise (50ms)
            ✔ via return from a rejected promise (50ms)
          calling `resolvePromise` with an asynchronously-rejected promise, then calling it again, both times synchronously
            ✔ via return from a fulfilled promise (51ms)
            ✔ via return from a rejected promise (50ms)
          calling `rejectPromise` twice synchronously
            ✔ via return from a fulfilled promise
            ✔ via return from a rejected promise
          calling `rejectPromise` twice, first synchronously then asynchronously
            ✔ via return from a fulfilled promise
            ✔ via return from a rejected promise
          calling `rejectPromise` twice, both times asynchronously
            ✔ via return from a fulfilled promise
            ✔ via return from a rejected promise
          saving and abusing `resolvePromise` and `rejectPromise`
            ✔ via return from a fulfilled promise (101ms)
            ✔ via return from a rejected promise (100ms)
        2.3.3.3.4: If calling `then` throws an exception `e`,
          2.3.3.3.4.1: If `resolvePromise` or `rejectPromise` have been called, ignore it.
            `resolvePromise` was called with a non-thenable
              ✔ via return from a fulfilled promise
              ✔ via return from a rejected promise
            `resolvePromise` was called with an asynchronously-fulfilled promise
              ✔ via return from a fulfilled promise (50ms)
              ✔ via return from a rejected promise (50ms)
            `resolvePromise` was called with an asynchronously-rejected promise
              ✔ via return from a fulfilled promise (51ms)
              ✔ via return from a rejected promise (50ms)
            `rejectPromise` was called
              ✔ via return from a fulfilled promise
              ✔ via return from a rejected promise
            `resolvePromise` then `rejectPromise` were called
              ✔ via return from a fulfilled promise
              ✔ via return from a rejected promise
            `rejectPromise` then `resolvePromise` were called
              ✔ via return from a fulfilled promise
              ✔ via return from a rejected promise
          2.3.3.3.4.2: Otherwise, reject `promise` with `e` as the reason.
            straightforward case
              ✔ via return from a fulfilled promise
              ✔ via return from a rejected promise
            `resolvePromise` is called asynchronously before the `throw`
              ✔ via return from a fulfilled promise
              ✔ via return from a rejected promise
            `rejectPromise` is called asynchronously before the `throw`
              ✔ via return from a fulfilled promise
              ✔ via return from a rejected promise
      2.3.3.4: If `then` is not a function, fulfill promise with `x`
        `then` is `5`
          ✔ via return from a fulfilled promise
          ✔ via return from a rejected promise
        `then` is an object
          ✔ via return from a fulfilled promise
          ✔ via return from a rejected promise
        `then` is an array containing a function
          ✔ via return from a fulfilled promise
          ✔ via return from a rejected promise
        `then` is a regular expression
          ✔ via return from a fulfilled promise
          ✔ via return from a rejected promise
        `then` is an object inheriting from `Function.prototype`
          ✔ via return from a fulfilled promise
          ✔ via return from a rejected promise
    2.3.4: If `x` is not an object or function, fulfill `promise` with `x`
      The value is `undefined`
        ✔ already-fulfilled
        ✔ immediately-fulfilled
        ✔ eventually-fulfilled (50ms)
        ✔ already-rejected
        ✔ immediately-rejected
        ✔ eventually-rejected (50ms)
      The value is `null`
        ✔ already-fulfilled
        ✔ immediately-fulfilled
        ✔ eventually-fulfilled (50ms)
        ✔ already-rejected
        ✔ immediately-rejected
        ✔ eventually-rejected (50ms)
      The value is `false`
        ✔ already-fulfilled
        ✔ immediately-fulfilled
        ✔ eventually-fulfilled (50ms)
        ✔ already-rejected
        ✔ immediately-rejected
        ✔ eventually-rejected (50ms)
      The value is `true`
        ✔ already-fulfilled
        ✔ immediately-fulfilled
        ✔ eventually-fulfilled (50ms)
        ✔ already-rejected
        ✔ immediately-rejected
        ✔ eventually-rejected (50ms)
      The value is `0`
        ✔ already-fulfilled
        ✔ immediately-fulfilled
        ✔ eventually-fulfilled (50ms)
        ✔ already-rejected
        ✔ immediately-rejected
        ✔ eventually-rejected (50ms)
      The value is `true` with `Boolean.prototype` modified to have a `then` method
        ✔ already-fulfilled
        ✔ immediately-fulfilled
        ✔ eventually-fulfilled (51ms)
        ✔ already-rejected
        ✔ immediately-rejected
        ✔ eventually-rejected (50ms)
      The value is `1` with `Number.prototype` modified to have a `then` method
        ✔ already-fulfilled
        ✔ immediately-fulfilled
        ✔ eventually-fulfilled (51ms)
        ✔ already-rejected
        ✔ immediately-rejected
        ✔ eventually-rejected (50ms)


  885 passing (19s)
  5 failing

  1) Promise.all
       should resolve empty array to empty array:
     Error: Timeout of 2000ms exceeded. For async tests and hooks, ensure "done()" is called; if returning a Promise, ensure it resolves. (/<<PKGBUILDDIR>>/test.js)
      at createTimeoutError (/usr/share/nodejs/mocha/lib/errors.js:386:15)
      at Runnable._timeoutError (/usr/share/nodejs/mocha/lib/runnable.js:431:10)
      at Timeout.<anonymous> (/usr/share/nodejs/mocha/lib/runnable.js:246:24)
      at listOnTimeout (node:internal/timers:605:17)
      at process.processTimers (node:internal/timers:541:7)

  2) Promise.all
       should resolve values to array:
     Error: Timeout of 2000ms exceeded. For async tests and hooks, ensure "done()" is called; if returning a Promise, ensure it resolves. (/<<PKGBUILDDIR>>/test.js)
      at createTimeoutError (/usr/share/nodejs/mocha/lib/errors.js:386:15)
      at Runnable._timeoutError (/usr/share/nodejs/mocha/lib/runnable.js:431:10)
      at Timeout.<anonymous> (/usr/share/nodejs/mocha/lib/runnable.js:246:24)
      at listOnTimeout (node:internal/timers:605:17)
      at process.processTimers (node:internal/timers:541:7)

  3) Promise.all
       should resolve promises to array:
     Error: Timeout of 2000ms exceeded. For async tests and hooks, ensure "done()" is called; if returning a Promise, ensure it resolves. (/<<PKGBUILDDIR>>/test.js)
      at createTimeoutError (/usr/share/nodejs/mocha/lib/errors.js:386:15)
      at Runnable._timeoutError (/usr/share/nodejs/mocha/lib/runnable.js:431:10)
      at Timeout.<anonymous> (/usr/share/nodejs/mocha/lib/runnable.js:246:24)
      at listOnTimeout (node:internal/timers:605:17)
      at process.processTimers (node:internal/timers:541:7)

  4) unhandledRejection/rejectionHandled events
       should not emit any events if handled before the next turn:
     Uncaught TypeError: util.isDate is not a function
      at _deepEqual (debian/tests/test_modules/core-assert/index.js:173:19)
      at ok.deepEqual (debian/tests/test_modules/core-assert/index.js:153:8)
      at Immediate.<anonymous> (test.js:196:11)
      at process.processImmediate (node:internal/timers:504:21)

  5) unhandledRejection/rejectionHandled events
       should not emit any events when handled by a chained promise:
     Uncaught TypeError: util.isDate is not a function
      at _deepEqual (debian/tests/test_modules/core-assert/index.js:173:19)
      at ok.deepStrictEqual (debian/tests/test_modules/core-assert/index.js:159:8)
      at Timeout._onTimeout (test.js:225:11)
      at listOnTimeout (node:internal/timers:605:17)
      at process.processTimers (node:internal/timers:541:7)



dh_auto_test: error: /bin/sh -ex debian/tests/pkg-js/test returned exit code 5
make: *** [debian/rules:8: binary] Error 25
dpkg-buildpackage: error: debian/rules binary subprocess failed with exit status 2
--------------------------------------------------------------------------------