[Pkg-javascript-devel] Bug#1002262: node-trust-webcrypto: FTBFS: make[1]: *** [debian/rules:18: override_dh_auto_test] Error 1
Lucas Nussbaum
lucas at debian.org
Tue Dec 21 16:48:09 GMT 2021
Source: node-trust-webcrypto
Version: 0.9.2-1
Severity: serious
Justification: FTBFS
Tags: bookworm sid ftbfs
User: lucas at debian.org
Usertags: ftbfs-20211220 ftbfs-bookworm
Hi,
During a rebuild of all packages in sid, your package failed to build
on amd64.
Relevant part (hopefully):
> make[1]: Entering directory '/<<PKGBUILDDIR>>'
> NODE_ENV=test prove --verbose \
> --exec "mocha --reporter=tap" \
> test/*.js test/*/*.js
> test/CryptoSpec.js ..............................
> ok 1 Crypto getRandomValues should return the typed array argument
> ok 2 Crypto getRandomValues should write random values to the typed array
> ok 3 Crypto subtle should return a SubtleCrypto instance
> # tests 3
> # pass 3
> # fail 0
> 1..3
> ok
>
> Error: Invalid type
> at SupportedKeyTypes.normalize (/usr/share/nodejs/@trust/keyto/src/types/SupportedKeyTypes.js:70:13)
> at Key.get alg [as alg] (/usr/share/nodejs/@trust/keyto/src/index.js:314:65)
> at Key.parseKey (/usr/share/nodejs/@trust/keyto/src/index.js:336:11)
> at new Key (/usr/share/nodejs/@trust/keyto/src/index.js:123:21)
> at Function.from (/usr/share/nodejs/@trust/keyto/src/index.js:209:14)
> at ECDSA.importKey (/<<PKGBUILDDIR>>/src/algorithms/ECDSA.js:301:27)
> at Object.<anonymous> (/<<PKGBUILDDIR>>/test/EcdsaKeyPairsForTesting.js:17:41)
> at Module._compile (internal/modules/cjs/loader.js:999:30)
> at Object.Module._extensions..js (internal/modules/cjs/loader.js:1027:10)
> at Module.load (internal/modules/cjs/loader.js:863:32)
> at Function.Module._load (internal/modules/cjs/loader.js:708:14)
> at ModuleWrap.<anonymous> (internal/modules/esm/translators.js:188:29)
> at ModuleJob.run (internal/modules/esm/module_job.js:145:37)
> at async Loader.import (internal/modules/esm/loader.js:182:24)
> at async formattedImport (/usr/share/nodejs/mocha/lib/nodejs/esm-utils.js:7:14)
> at async Object.exports.requireOrImport (/usr/share/nodejs/mocha/lib/nodejs/esm-utils.js:48:32)
> at async Object.exports.loadFilesAsync (/usr/share/nodejs/mocha/lib/nodejs/esm-utils.js:88:20)
> at async singleRun (/usr/share/nodejs/mocha/lib/cli/run-helpers.js:125:3)
> at async Object.exports.handler (/usr/share/nodejs/mocha/lib/cli/run.js:374:5)
> test/EcdsaKeyPairsForTesting.js .................
> Dubious, test returned 1 (wstat 256, 0x100)
> No subtests run
> test/RsaKeyPairForPSSTesting.js ................. skipped: (no reason given)
> test/RsaKeyPairForTesting.js .................... skipped: (no reason given)
> (node:934098) [DEP0005] DeprecationWarning: Buffer() is deprecated due to security and usability issues. Please use the Buffer.alloc(), Buffer.allocUnsafe(), or Buffer.from() methods instead.
> test/SubtleCryptoSpec.js ........................
> ok 1 SubtleCrypto encrypt with invalid algorithm should return a promise
> ok 2 SubtleCrypto encrypt with invalid algorithm should reject the promise
> ok 3 SubtleCrypto encrypt with mismatched algorithm name should return a promise
> ok 4 SubtleCrypto encrypt with mismatched algorithm name should reject the promise
> ok 5 SubtleCrypto encrypt with invalid usages should return a promise
> ok 6 SubtleCrypto encrypt with invalid usages should reject the promise
> ok 7 SubtleCrypto encrypt with valid arguments should return a promise
> ok 8 SubtleCrypto encrypt with valid arguments should resolve an ArrayBuffer
> ok 9 SubtleCrypto encrypt with valid arguments should resolve a correct encryption for the data and key
> ok 10 SubtleCrypto encrypt with valid arguments should not reject the promise
> ok 11 SubtleCrypto decrypt with invalid algorithm should return a promise
> ok 12 SubtleCrypto decrypt with invalid algorithm should reject the promise
> ok 13 SubtleCrypto decrypt with mismatched algorithm name should return a promise
> ok 14 SubtleCrypto decrypt with mismatched algorithm name should reject the promise
> ok 15 SubtleCrypto decrypt with invalid usages should return a promise
> ok 16 SubtleCrypto decrypt with invalid usages should reject the promise
> ok 17 SubtleCrypto decrypt with valid arguments should return a promise
> ok 18 SubtleCrypto decrypt with valid arguments should resolve a correct decryption for the data and key
> ok 19 SubtleCrypto decrypt with valid arguments should not reject the promise
> ok 20 SubtleCrypto sign with invalid algorithm should return a promise
> ok 21 SubtleCrypto sign with invalid algorithm should reject the promise
> ok 22 SubtleCrypto sign with mismatched algorithm name should return a promise
> ok 23 SubtleCrypto sign with mismatched algorithm name should reject the promise
> ok 24 SubtleCrypto sign with invalid usages should return a promise
> ok 25 SubtleCrypto sign with invalid usages should reject the promise
> ok 26 SubtleCrypto sign with valid arguments should return a promise
> ok 27 SubtleCrypto sign with valid arguments should resolve an ArrayBuffer
> ok 28 SubtleCrypto sign with valid arguments should resolve a correct signature for the data and key
> ok 29 SubtleCrypto sign with valid arguments should not reject the promise
> ok 30 SubtleCrypto verify with invalid algorithm should return a promise
> ok 31 SubtleCrypto verify with invalid algorithm should reject the promise
> ok 32 SubtleCrypto verify with mismatched algorithm name should return a promise
> ok 33 SubtleCrypto verify with mismatched algorithm name should reject the promise
> ok 34 SubtleCrypto verify with invalid usages should return a promise
> ok 35 SubtleCrypto verify with invalid usages should reject the promise
> ok 36 SubtleCrypto verify with valid arguments should return a promise
> ok 37 SubtleCrypto verify with valid arguments should resolve the promise
> ok 38 SubtleCrypto verify with valid arguments should not reject the promise
> ok 39 SubtleCrypto digest with invalid algorithm should return a promise
> ok 40 SubtleCrypto digest with invalid algorithm should reject the promise
> ok 41 SubtleCrypto digest with valid arguments should return a promise
> ok 42 SubtleCrypto digest with valid arguments should resolve an ArrayBuffer
> ok 43 SubtleCrypto digest with valid arguments should not reject the promise
> ok 44 SubtleCrypto generateKey with invalid algorithm should return a promise
> ok 45 SubtleCrypto generateKey with invalid algorithm should reject the promise
> ok 46 SubtleCrypto generateKey with invalid CryptoKey usages should return a promise # SKIP -
> ok 47 SubtleCrypto generateKey with invalid CryptoKey usages should reject the promise # SKIP -
> ok 48 SubtleCrypto generateKey with invalid CryptoKeyPair usages should return a promise # SKIP -
> ok 49 SubtleCrypto generateKey with invalid CryptoKeyPair usages should reject the promise # SKIP -
> ok 50 SubtleCrypto generateKey with valid arguments should return a promise
> ok 51 SubtleCrypto generateKey with valid arguments should resolve the promise # SKIP -
> ok 52 SubtleCrypto generateKey with valid arguments should not reject the promise # SKIP -
> ok 53 SubtleCrypto deriveKey should return a Promise # SKIP -
> ok 54 SubtleCrypto deriveBits should return a Promise # SKIP -
> ok 55 SubtleCrypto importKey with invalid algorithm should return a promise
> ok 56 SubtleCrypto importKey with invalid algorithm should reject the promise
> ok 57 SubtleCrypto importKey with valid arguments should return a promise
> ok 58 SubtleCrypto importKey with valid arguments should resolve the promise
> ok 59 SubtleCrypto importKey with valid arguments should set extractable
> ok 60 SubtleCrypto importKey with valid arguments should normalize key usages
> ok 61 SubtleCrypto importKey with valid arguments should not reject the promise
> ok 62 SubtleCrypto exportKey with invalid algorithm should return a promise
> ok 63 SubtleCrypto exportKey with invalid algorithm should reject the promise
> ok 64 SubtleCrypto exportKey with unextractable key should return a promise
> ok 65 SubtleCrypto exportKey with unextractable key should reject the promise
> ok 66 SubtleCrypto exportKey with valid arguments should return a promise
> ok 67 SubtleCrypto exportKey with valid arguments should resolve the promise
> ok 68 SubtleCrypto exportKey with valid arguments should not reject the promise
> ok 69 SubtleCrypto wrapKey with invalid algorithm should return a promise
> ok 70 SubtleCrypto wrapKey with invalid algorithm should reject the promise
> ok 71 SubtleCrypto wrapKey with invalid name property should reject the promise # SKIP -
> ok 72 SubtleCrypto wrapKey with invalid key ops should reject the promise # SKIP -
> ok 73 SubtleCrypto wrapKey with invalid extractable property should reject the promise # SKIP -
> ok 74 SubtleCrypto wrapKey with valid arguments should return a promise
> ok 75 SubtleCrypto wrapKey with valid arguments should resolve the promise
> ok 76 SubtleCrypto wrapKey with valid arguments should not reject the promise
> ok 77 SubtleCrypto unwrapKey with invalid algorithm should return a promise
> ok 78 SubtleCrypto unwrapKey with invalid algorithm should reject the promise
> ok 79 SubtleCrypto unwrapKey with invalid name property should reject the promise # SKIP -
> ok 80 SubtleCrypto unwrapKey with invalid key ops should reject the promise # SKIP -
> ok 81 SubtleCrypto unwrapKey with different key arguments should resolve the promise # SKIP -
> ok 82 SubtleCrypto unwrapKey with valid arguments should return a promise
> ok 83 SubtleCrypto unwrapKey with valid arguments should resolve the promise
> ok 84 SubtleCrypto unwrapKey with valid arguments should not reject the promise
> # tests 70
> # pass 70
> # fail 0
> 1..84
> ok
> test/algorithms/AES-CBCSpec.js ..................
> ok 1 AES_CBC dictionaries getter should return an array # SKIP -
> ok 2 AES_CBC members getter should return an object # SKIP -
> ok 3 AES_CBC encrypt should throw with invalid iv length
> ok 4 AES_CBC encrypt should return an ArrayBuffer
> ok 5 AES_CBC encrypt should return a valid encryption
> ok 6 AES_CBC decrypt should throw with invalid iv length
> ok 7 AES_CBC decrypt should return an ArrayBuffer
> ok 8 AES_CBC decrypt should return a valid encryption
> ok 9 AES_CBC generateKey should throw with invalid usages
> ok 10 AES_CBC generateKey should throw with invalid paramater length
> ok 11 AES_CBC generateKey should return CryptoKey
> ok 12 AES_CBC generateKey should be a secret key type
> ok 13 AES_CBC generateKey should have AES_CBC type for algorithm
> ok 14 AES_CBC generateKey should set algorithm name
> ok 15 AES_CBC generateKey should set key as extractable
> ok 16 AES_CBC generateKey should set key usages
> ok 17 AES_CBC generateKey should have correct length key handle
> ok 18 AES_CBC generateKey should generate a random handle each time
> ok 19 AES_CBC importKey should expect only "raw" or "jwk" formats
> ok 20 AES_CBC importKey with "raw" format should expect a suitable raw length
> ok 21 AES_CBC importKey with "raw" format should be a secret key type
> ok 22 AES_CBC importKey with "raw" format should have AES_CBC type for algorithm
> ok 23 AES_CBC importKey with "raw" format should set algorithm name
> ok 24 AES_CBC importKey with "raw" format should set key as extractable
> ok 25 AES_CBC importKey with "raw" format should set key usages
> ok 26 AES_CBC importKey with "raw" format should have correct length key handle
> ok 27 AES_CBC importKey with "jwk" format should expect a suitable jwk format
> ok 28 AES_CBC importKey with "jwk" format should expect correct kty format
> ok 29 AES_CBC importKey with "jwk" format should expect data in k property
> ok 30 AES_CBC importKey with "jwk" format should expect A128CBC when data length is 16
> ok 31 AES_CBC importKey with "jwk" format should expect A192CBC when data length is 24
> ok 32 AES_CBC importKey with "jwk" format should expect A256CBC when data length is 32
> ok 33 AES_CBC importKey with "jwk" format should expect mismatched length when k is not appropriate base64url
> ok 34 AES_CBC importKey with "jwk" format should expect correct value when "use" field is used
> ok 35 AES_CBC importKey with "jwk" format should expect valid key operations
> ok 36 AES_CBC importKey with "jwk" format should expect non extractable to not be extractable
> ok 37 AES_CBC importKey with "jwk" format should be a secret key type
> ok 38 AES_CBC importKey with "jwk" format should have AES_CBC type for algorithm
> ok 39 AES_CBC importKey with "jwk" format should set algorithm name
> ok 40 AES_CBC importKey with "jwk" format should set key as extractable
> ok 41 AES_CBC importKey with "jwk" format should set key usages
> ok 42 AES_CBC importKey with "jwk" format should have correct length key handle
> ok 43 AES_CBC exportKey should have a valid handle in the key
> ok 44 AES_CBC exportKey should expect only "raw" or "jwk" formats
> ok 45 AES_CBC exportKey with "raw" format should return a valid object
> ok 46 AES_CBC exportKey with "jwk" format should return a valid object
> ok 47 AES_CBC exportKey with "jwk" format should expect correct kty field
> ok 48 AES_CBC exportKey with "jwk" format should expect A128CBC when data length is 16
> ok 49 AES_CBC exportKey with "jwk" format should expect A192CBC when data length is 24
> ok 50 AES_CBC exportKey with "jwk" format should expect A256CBC when data length is 32
> # tests 48
> # pass 48
> # fail 0
> 1..50
> ok
> test/algorithms/AES-CTRSpec.js ..................
> ok 1 AES_CTR dictionaries getter should return an array # SKIP -
> ok 2 AES_CTR members getter should return an object # SKIP -
> ok 3 AES_CTR encrypt should throw with empty counter
> ok 4 AES_CTR encrypt should throw with invalid counter
> ok 5 AES_CTR encrypt should throw with length value
> ok 6 AES_CTR encrypt should return an ArrayBuffer
> ok 7 AES_CTR encrypt should return a valid encryption
> ok 8 AES_CTR decrypt should throw with empty counter
> ok 9 AES_CTR decrypt should throw with invalid counter
> ok 10 AES_CTR decrypt should throw with invalid length value
> ok 11 AES_CTR decrypt should return an ArrayBuffer
> ok 12 AES_CTR decrypt should return a valid decryption
> ok 13 AES_CTR generateKey should throw with invalid usages
> ok 14 AES_CTR generateKey should throw with invalid parameter length
> ok 15 AES_CTR generateKey should return CryptoKey
> ok 16 AES_CTR generateKey should be a secret key type
> ok 17 AES_CTR generateKey should have AES_CTR type for algorithm
> ok 18 AES_CTR generateKey should set algorithm name
> ok 19 AES_CTR generateKey should set key as extractable
> ok 20 AES_CTR generateKey should set key usages
> ok 21 AES_CTR generateKey should have correct length key handle
> ok 22 AES_CTR generateKey should generate a random handle each time
> ok 23 AES_CTR importKey should throw with invalid usages
> ok 24 AES_CTR importKey should expect only "raw" or "jwk" formats
> ok 25 AES_CTR importKey with "raw" format should expect a suitable raw length
> ok 26 AES_CTR importKey with "raw" format should be a secret key type
> ok 27 AES_CTR importKey with "raw" format should have AES_CTR type for algorithm
> ok 28 AES_CTR importKey with "raw" format should set algorithm name
> ok 29 AES_CTR importKey with "raw" format should set key as extractable
> ok 30 AES_CTR importKey with "raw" format should set key usages
> ok 31 AES_CTR importKey with "raw" format should have correct length key handle
> ok 32 AES_CTR importKey with "jwk" format should expect a suitable jwk format
> ok 33 AES_CTR importKey with "jwk" format should expect correct kty format
> ok 34 AES_CTR importKey with "jwk" format should expect data in k property
> ok 35 AES_CTR importKey with "jwk" format should expect A128CTR when data length is 16
> ok 36 AES_CTR importKey with "jwk" format should expect A192CTR when data length is 24
> ok 37 AES_CTR importKey with "jwk" format should expect A256CTR when data length is 32
> ok 38 AES_CTR importKey with "jwk" format should expect mismatched length when k is not appropriate base64url
> ok 39 AES_CTR importKey with "jwk" format should expect correct value when "use" field is used
> ok 40 AES_CTR importKey with "jwk" format should expect valid key operations
> ok 41 AES_CTR importKey with "jwk" format should expect non extractable to not be extractable
> ok 42 AES_CTR importKey with "jwk" format should be a secret key type
> ok 43 AES_CTR importKey with "jwk" format should have AES_CTR type for algorithm
> ok 44 AES_CTR importKey with "jwk" format should set algorithm name
> ok 45 AES_CTR importKey with "jwk" format should set key as extractable
> ok 46 AES_CTR importKey with "jwk" format should set key usages
> ok 47 AES_CTR importKey with "jwk" format should have correct length key handle
> ok 48 AES_CTR exportKey should have a valid handle in the key
> ok 49 AES_CTR exportKey should expect only "raw" or "jwk" formats
> ok 50 AES_CTR exportKey with "raw" format should return a valid object
> ok 51 AES_CTR exportKey with "raw" format should be the same as the Chrome exported key
> ok 52 AES_CTR exportKey with "jwk" format should return a valid object
> ok 53 AES_CTR exportKey with "jwk" format should expect correct kty field
> ok 54 AES_CTR exportKey with "jwk" format should expect A128CTR when data length is 16
> ok 55 AES_CTR exportKey with "jwk" format should expect A192CTR when data length is 24
> ok 56 AES_CTR exportKey with "jwk" format should expect A256CTR when data length is 32
> # tests 54
> # pass 54
> # fail 0
> 1..56
> ok
> test/algorithms/AES-GCMSpec.js ..................
> ok 1 AES_GCM dictionaries getter should return an array # SKIP -
> ok 2 AES_GCM members getter should return an object # SKIP -
> ok 3 AES_GCM encrypt should throw invalid data length
> ok 4 AES_GCM encrypt should throw with invalid iv length
> ok 5 AES_GCM encrypt should throw with invalid additionalData
> ok 6 AES_GCM encrypt should accept an ArrayBuffer
> ok 7 AES_GCM encrypt should return an ArrayBuffer
> ok 8 AES_GCM encrypt should return a valid encryption
> ok 9 AES_GCM decrypt should throw with invalid tagLength
> ok 10 AES_GCM decrypt should throw with unsupported tagLength
> ok 11 AES_GCM decrypt should throw with invalid data length
> ok 12 AES_GCM decrypt should throw with invalid data length
> ok 13 AES_GCM decrypt should throw with invalid iv length
> ok 14 AES_GCM decrypt should throw with invalid additionalData
> ok 15 AES_GCM decrypt should return an ArrayBuffer
> ok 16 AES_GCM decrypt should return a valid decryption
> ok 17 AES_GCM generateKey should throw with invalid usages
> ok 18 AES_GCM generateKey should throw with invalid parameter length
> ok 19 AES_GCM generateKey should return CryptoKey
> ok 20 AES_GCM generateKey should be a secret key type
> ok 21 AES_GCM generateKey should have AES_GCM type for algorithm
> ok 22 AES_GCM generateKey should set algorithm name
> ok 23 AES_GCM generateKey should set key as extractable
> ok 24 AES_GCM generateKey should set key usages
> ok 25 AES_GCM generateKey should have correct length key handle
> ok 26 AES_GCM generateKey should generate a random handle each time
> ok 27 AES_GCM importKey should throw with invalid usages
> ok 28 AES_GCM importKey should expect only "raw" or "jwk" formats
> ok 29 AES_GCM importKey with "raw" format should expect a suitable raw length
> ok 30 AES_GCM importKey with "raw" format should be a secret key type
> ok 31 AES_GCM importKey with "raw" format should have AES_GCM type for algorithm
> ok 32 AES_GCM importKey with "raw" format should set algorithm name
> ok 33 AES_GCM importKey with "raw" format should set key as extractable
> ok 34 AES_GCM importKey with "raw" format should set key usages
> ok 35 AES_GCM importKey with "raw" format should have correct length key handle
> ok 36 AES_GCM importKey with "jwk" format should expect a suitable jwk format
> ok 37 AES_GCM importKey with "jwk" format should expect correct kty format
> ok 38 AES_GCM importKey with "jwk" format should expect data in k property
> ok 39 AES_GCM importKey with "jwk" format should expect A128GCM when data length is 16
> ok 40 AES_GCM importKey with "jwk" format should expect A192GCM when data length is 24
> ok 41 AES_GCM importKey with "jwk" format should expect A256GCM when data length is 32
> ok 42 AES_GCM importKey with "jwk" format should expect mismatched length when k is not appropriate base64url
> ok 43 AES_GCM importKey with "jwk" format should expect correct value when "use" field is used
> ok 44 AES_GCM importKey with "jwk" format should expect valid key operations
> ok 45 AES_GCM importKey with "jwk" format should expect non extractable to not be extractable
> ok 46 AES_GCM importKey with "jwk" format should be a secret key type
> ok 47 AES_GCM importKey with "jwk" format should have AES_GCM type for algorithm
> ok 48 AES_GCM importKey with "jwk" format should set algorithm name
> ok 49 AES_GCM importKey with "jwk" format should set key as extractable
> ok 50 AES_GCM importKey with "jwk" format should set key usages
> ok 51 AES_GCM importKey with "jwk" format should have correct length key handle
> ok 52 AES_GCM exportKey should have a valid handle in the key
> ok 53 AES_GCM exportKey should expect only "raw" or "jwk" formats
> ok 54 AES_GCM exportKey with "raw" format should return a valid object
> ok 55 AES_GCM exportKey with "jwk" format should return a valid object
> ok 56 AES_GCM exportKey with "jwk" format should expect correct kty field
> ok 57 AES_GCM exportKey with "jwk" format should expect A128GCM when data length is 16
> ok 58 AES_GCM exportKey with "jwk" format should expect A192GCM when data length is 24
> ok 59 AES_GCM exportKey with "jwk" format should expect A256GCM when data length is 32
> # tests 57
> # pass 57
> # fail 0
> 1..59
> ok
> test/algorithms/AES-KWSpec.js ...................
> ok 1 AES_KW dictionaries getter should return an array # SKIP -
> ok 2 AES_KW members getter should return an object # SKIP -
> ok 3 AES_KW wrapKey should return an ArrayBuffer
> ok 4 AES_KW wrapKey should return a valid wrapped key object
> ok 5 AES_KW wrapKey should fail with invalid key length
> ok 6 AES_KW unwrapKey should return an Array
> ok 7 AES_KW generateKey should throw with invalid usages
> ok 8 AES_KW generateKey should throw with invalid parameter length
> ok 9 AES_KW generateKey should return CryptoKey
> ok 10 AES_KW generateKey should be a secret key type
> ok 11 AES_KW generateKey should have AES_KW type for algorithm
> ok 12 AES_KW generateKey should set algorithm name
> ok 13 AES_KW generateKey should set key as extractable
> ok 14 AES_KW generateKey should set key usages
> ok 15 AES_KW generateKey should have correct length key handle
> ok 16 AES_KW generateKey should generate a random handle each time
> ok 17 AES_KW importKey should throw with invalid usages
> ok 18 AES_KW importKey should expect only "raw" or "jwk" formats
> ok 19 AES_KW importKey with "raw" format should expect a suitable raw length
> ok 20 AES_KW importKey with "raw" format should be a secret key type
> ok 21 AES_KW importKey with "raw" format should have AES_KW type for algorithm
> ok 22 AES_KW importKey with "raw" format should set algorithm name
> ok 23 AES_KW importKey with "raw" format should set key as extractable
> ok 24 AES_KW importKey with "raw" format should set key usages
> ok 25 AES_KW importKey with "raw" format should have correct length key handle
> ok 26 AES_KW importKey with "jwk" format should expect a suitable jwk format
> ok 27 AES_KW importKey with "jwk" format should expect correct kty format
> ok 28 AES_KW importKey with "jwk" format should expect data in k property
> ok 29 AES_KW importKey with "jwk" format should expect A128KW when data length is 16
> ok 30 AES_KW importKey with "jwk" format should expect A192KW when data length is 24
> ok 31 AES_KW importKey with "jwk" format should expect A256KW when data length is 32
> ok 32 AES_KW importKey with "jwk" format should expect mismatched length when k is not appropriate base64url
> ok 33 AES_KW importKey with "jwk" format should expect correct value when "use" field is used
> ok 34 AES_KW importKey with "jwk" format should expect valid key operations
> ok 35 AES_KW importKey with "jwk" format should expect non extractable to not be extractable
> ok 36 AES_KW importKey with "jwk" format should be a secret key type
> ok 37 AES_KW importKey with "jwk" format should have AES_KW type for algorithm
> ok 38 AES_KW importKey with "jwk" format should set algorithm name
> ok 39 AES_KW importKey with "jwk" format should set key as extractable
> ok 40 AES_KW importKey with "jwk" format should set key usages
> ok 41 AES_KW importKey with "jwk" format should have correct length key handle
> ok 42 AES_KW exportKey should have a valid handle in the key
> ok 43 AES_KW exportKey should expect only "raw" or "jwk" formats
> ok 44 AES_KW exportKey with "raw" format should return a valid object
> ok 45 AES_KW exportKey with "jwk" format should return a valid object
> ok 46 AES_KW exportKey with "jwk" format should expect correct kty field
> ok 47 AES_KW exportKey with "jwk" format should expect A128KW when data length is 16
> ok 48 AES_KW exportKey with "jwk" format should expect A192KW when data length is 24
> ok 49 AES_KW exportKey with "jwk" format should expect A256KW when data length is 32
> # tests 47
> # pass 47
> # fail 0
> 1..49
> ok
>
> Error: Invalid type
> at SupportedKeyTypes.normalize (/usr/share/nodejs/@trust/keyto/src/types/SupportedKeyTypes.js:70:13)
> at Key.get alg [as alg] (/usr/share/nodejs/@trust/keyto/src/index.js:314:65)
> at Key.parseKey (/usr/share/nodejs/@trust/keyto/src/index.js:336:11)
> at new Key (/usr/share/nodejs/@trust/keyto/src/index.js:123:21)
> at Function.from (/usr/share/nodejs/@trust/keyto/src/index.js:209:14)
> at ECDSA.importKey (/<<PKGBUILDDIR>>/src/algorithms/ECDSA.js:301:27)
> at Object.<anonymous> (/<<PKGBUILDDIR>>/test/EcdsaKeyPairsForTesting.js:17:41)
> at Module._compile (internal/modules/cjs/loader.js:999:30)
> at Object.Module._extensions..js (internal/modules/cjs/loader.js:1027:10)
> at Module.load (internal/modules/cjs/loader.js:863:32)
> at Function.Module._load (internal/modules/cjs/loader.js:708:14)
> at Module.require (internal/modules/cjs/loader.js:887:19)
> at require (internal/modules/cjs/helpers.js:74:18)
> at Object.<anonymous> (/<<PKGBUILDDIR>>/test/algorithms/ECDSASpec.js:44:5)
> at Module._compile (internal/modules/cjs/loader.js:999:30)
> at Object.Module._extensions..js (internal/modules/cjs/loader.js:1027:10)
> at Module.load (internal/modules/cjs/loader.js:863:32)
> at Function.Module._load (internal/modules/cjs/loader.js:708:14)
> at ModuleWrap.<anonymous> (internal/modules/esm/translators.js:188:29)
> at ModuleJob.run (internal/modules/esm/module_job.js:145:37)
> at async Loader.import (internal/modules/esm/loader.js:182:24)
> at async formattedImport (/usr/share/nodejs/mocha/lib/nodejs/esm-utils.js:7:14)
> at async Object.exports.requireOrImport (/usr/share/nodejs/mocha/lib/nodejs/esm-utils.js:48:32)
> at async Object.exports.loadFilesAsync (/usr/share/nodejs/mocha/lib/nodejs/esm-utils.js:88:20)
> at async singleRun (/usr/share/nodejs/mocha/lib/cli/run-helpers.js:125:3)
> at async Object.exports.handler (/usr/share/nodejs/mocha/lib/cli/run.js:374:5)
> test/algorithms/ECDSASpec.js ....................
> Dubious, test returned 1 (wstat 256, 0x100)
> No subtests run
> test/algorithms/EDDSASpec.js ....................
> ok 1 EDDSA dictionaries getter should return an array # SKIP -
> ok 2 EDDSA members getter should return an object # SKIP -
> ok 3 EDDSA sign should throw with non-private key
> ok 4 EDDSA sign should return an ArrayBuffer
> ok 5 EDDSA sign should return an EDDSA signature
> ok 6 EDDSA sign should throw with invalid data type
> ok 7 EDDSA verify should throw with non-private key
> ok 8 EDDSA verify should return true with valid signature
> ok 9 EDDSA verify should return false with invalid signature
> ok 10 EDDSA generateKey should throw with invalid usages
> ok 11 EDDSA generateKey should return CryptoKey
> ok 12 EDDSA generateKey should set public key type
> ok 13 EDDSA generateKey should set private key type
> ok 14 EDDSA generateKey should set public key algorithm
> ok 15 EDDSA generateKey should set private key algorithm
> ok 16 EDDSA generateKey should set public key algorithm name
> ok 17 EDDSA generateKey should set private key algorithm name
> ok 18 EDDSA generateKey should set public key extractable
> ok 19 EDDSA generateKey should set private key extractable
> ok 20 EDDSA generateKey should set public key usages
> ok 21 EDDSA generateKey should set private key usages
> ok 22 EDDSA importKey with "jwk" format private key and invalid usages should throw SyntaxError
> ok 23 EDDSA importKey with "jwk" format non-private key and invalid usages should throw SyntaxError
> ok 24 EDDSA importKey with "jwk" format invalid key type should throw DataError
> ok 25 EDDSA importKey with "jwk" format invalid key use should throw DataError
> ok 26 EDDSA importKey with "jwk" format private Ed25519 key should define type
> ok 27 EDDSA importKey with "jwk" format private Ed25519 key should define algorithm
> ok 28 EDDSA importKey with "jwk" format private Ed25519 key should define extractable
> ok 29 EDDSA importKey with "jwk" format private Ed25519 key should define usages
> ok 30 EDDSA importKey with "jwk" format public Ed25519 key should define type
> ok 31 EDDSA importKey with "jwk" format public Ed25519 key should define algorithm
> ok 32 EDDSA importKey with "jwk" format public Ed25519 key should define extractable
> ok 33 EDDSA importKey with "jwk" format public Ed25519 key should define usages
> ok 34 EDDSA importKey with "hex" format private key and invalid usages should throw SyntaxError
> ok 35 EDDSA importKey with "hex" format non-private key and invalid usages should throw SyntaxError
> ok 36 EDDSA importKey with "hex" format invalid key type should throw DataError
> ok 37 EDDSA importKey with "hex" format invalid key use should throw DataError
> ok 38 EDDSA importKey with "hex" format private Ed25519 key should define type
> ok 39 EDDSA importKey with "hex" format private Ed25519 key should define algorithm
> ok 40 EDDSA importKey with "hex" format private Ed25519 key should define extractable
> ok 41 EDDSA importKey with "hex" format private Ed25519 key should define usages
> ok 42 EDDSA importKey with "hex" format public Ed25519 key should define type
> ok 43 EDDSA importKey with "hex" format public Ed25519 key should define algorithm
> ok 44 EDDSA importKey with "hex" format public Ed25519 key should define extractable
> ok 45 EDDSA importKey with "hex" format public Ed25519 key should define usages
> ok 46 EDDSA importKey with other format should throw NotSupportedError
> ok 47 EDDSA exportKey with missing key material should throw OperationError
> ok 48 EDDSA exportKey with "jwk" format should return a valid key
> ok 49 EDDSA exportKey with "raw" format should return a valid key
> ok 50 EDDSA exportKey with "hex" format should return a valid key
> ok 51 EDDSA exportKey with other format should throw NotSupportedError
> # tests 49
> # pass 49
> # fail 0
> 1..51
> ok
> (node:934149) [DEP0005] DeprecationWarning: Buffer() is deprecated due to security and usability issues. Please use the Buffer.alloc(), Buffer.allocUnsafe(), or Buffer.from() methods instead.
> test/algorithms/HMACSpec.js .....................
> ok 1 HMAC dictionaries getter should return an array
> ok 2 HMAC members getter should return an object
> ok 3 HMAC sign should return an ArrayBuffer
> ok 4 HMAC sign should return a HMAC signature
> ok 5 HMAC verify should verify a valid HMAC signature
> ok 6 HMAC verify should not verify an invalid HMAC signature
> ok 7 HMAC generateKey should throw with invalid usages
> ok 8 HMAC generateKey should throw with invalid length
> ok 9 HMAC generateKey should return CryptoKey
> ok 10 HMAC generateKey should set key type
> ok 11 HMAC generateKey should set key algorithm
> ok 12 HMAC generateKey should set key algorithm name
> ok 13 HMAC generateKey should set key algorithm hash
> ok 14 HMAC generateKey should set key algorithm hash name
> ok 15 HMAC generateKey should set key extractable
> ok 16 HMAC generateKey should set key usages
> ok 17 HMAC generateKey should set key handle
> ok 18 HMAC importKey should throw with invalid usages
> ok 19 HMAC importKey should throw with missing algorithm hash
> ok 20 HMAC importKey should throw with unsupported key format
> ok 21 HMAC importKey should throw with empty key data
> ok 22 HMAC importKey should import raw key data and return a CryptoKey
> ok 23 HMAC importKey should set key type
> ok 24 HMAC importKey should set key algorithm
> ok 25 HMAC importKey should set key algorithm name
> ok 26 HMAC importKey should set key algorithm hash name
> ok 27 HMAC importKey should set key extractable
> ok 28 HMAC importKey should set key usages
> ok 29 HMAC importKey should set key handle
> ok 30 HMAC exportKey should throw with invalid usages
> ok 31 HMAC exportKey should throw with unsupported key format
> ok 32 HMAC exportKey should return a raw key
> # tests 32
> # pass 32
> # fail 0
> 1..32
> ok
> (node:934156) [DEP0005] DeprecationWarning: Buffer() is deprecated due to security and usability issues. Please use the Buffer.alloc(), Buffer.allocUnsafe(), or Buffer.from() methods instead.
> test/algorithms/RSA-OAEPspec.js .................
> ok 1 RSA_OAEP dictionaries getter should return an array # SKIP -
> ok 2 RSA_OAEP members getter should return an object # SKIP -
> ok 3 RSA_OAEP encrypt should throw with non-private key
> ok 4 RSA_OAEP encrypt should return an ArrayBuffer
> ok 5 RSA_OAEP decrypt should throw with non-private key
> ok 6 RSA_OAEP decrypt should return an ArrayBuffer
> ok 7 RSA_OAEP decrypt should return a valid decryption
> ok 8 RSA_OAEP generateKey should throw with invalid usages # SKIP -
> ok 9 RSA_OAEP generateKey should return CryptoKey # SKIP -
> ok 10 RSA_OAEP generateKey should set public key type # SKIP -
> ok 11 RSA_OAEP generateKey should set private key type # SKIP -
> ok 12 RSA_OAEP generateKey should set public key algorithm # SKIP -
> ok 13 RSA_OAEP generateKey should set private key algorithm # SKIP -
> ok 14 RSA_OAEP generateKey should set public key algorithm name # SKIP -
> ok 15 RSA_OAEP generateKey should set private key algorithm name # SKIP -
> ok 16 RSA_OAEP generateKey should set public key algorithm hash name # SKIP -
> ok 17 RSA_OAEP generateKey should set private key algorithm hash name # SKIP -
> ok 18 RSA_OAEP generateKey should set public key extractable # SKIP -
> ok 19 RSA_OAEP generateKey should set private key extractable # SKIP -
> ok 20 RSA_OAEP generateKey should set public key usages # SKIP -
> ok 21 RSA_OAEP generateKey should set private key usages # SKIP -
> ok 22 RSA_OAEP generateKey should set public key handle # SKIP -
> ok 23 RSA_OAEP generateKey should set private key handle # SKIP -
> ok 24 RSA_OAEP importKey with "jwk" format private key and invalid usages should throw SyntaxError
> ok 25 RSA_OAEP importKey with "jwk" format non-private key and invalid usages should throw SyntaxError
> ok 26 RSA_OAEP importKey with "jwk" format invalid key type should throw DataError
> ok 27 RSA_OAEP importKey with "jwk" format invalid key use should throw DataError
> ok 28 RSA_OAEP importKey with "jwk" format RSA-OAEP key alg should set SHA-1 hash
> ok 29 RSA_OAEP importKey with "jwk" format RSA-OAEP-256 key alg should set SHA-256 hash
> ok 30 RSA_OAEP importKey with "jwk" format RSA-OAEP-384 key alg should set SHA-384 hash
> ok 31 RSA_OAEP importKey with "jwk" format RSA-OAEP-512 key alg should set SHA-512 hash
> ok 32 RSA_OAEP importKey with "jwk" format invalid key alg should throw DataError
> ok 33 RSA_OAEP importKey with "jwk" format private RSA key should define type
> ok 34 RSA_OAEP importKey with "jwk" format private RSA key should define algorithm
> ok 35 RSA_OAEP importKey with "jwk" format private RSA key should define extractable
> ok 36 RSA_OAEP importKey with "jwk" format private RSA key should define usages
> ok 37 RSA_OAEP importKey with "jwk" format private RSA key should define handle
> ok 38 RSA_OAEP importKey with "jwk" format public RSA key should define type
> ok 39 RSA_OAEP importKey with "jwk" format public RSA key should define algorithm
> ok 40 RSA_OAEP importKey with "jwk" format public RSA key should define extractable
> ok 41 RSA_OAEP importKey with "jwk" format public RSA key should define usages
> ok 42 RSA_OAEP importKey with "jwk" format public RSA key should define handle
> ok 43 RSA_OAEP importKey with other format should throw NotSupportedError
> ok 44 RSA_OAEP exportKey with missing key material should throw OperationError
> ok 45 RSA_OAEP exportKey with "jwk" format SHA-1 hash should set "alg" to "RSA-OAEP"
> ok 46 RSA_OAEP exportKey with "jwk" format SHA-256 hash should set "alg" to "RSA-OAEP-256"
> ok 47 RSA_OAEP exportKey with "jwk" format SHA-384 hash should set "alg" to "RSA-OAEP-384"
> ok 48 RSA_OAEP exportKey with "jwk" format SHA-512 hash should set "alg" to "RSA-OAEP-512"
> ok 49 RSA_OAEP exportKey with other format should throw NotSupportedError
> # tests 31
> # pass 31
> # fail 0
> 1..49
> ok
> test/algorithms/RSA-PSSSpec.js ..................
> ok 1 dictionaries getter should return an array # SKIP -
> ok 2 members getter should return an object # SKIP -
> ok 3 sign should throw with non-private key
> ok 4 sign should return an ArrayBuffer
> ok 5 sign should return a correct length RSA-PSS SHA-1 signature
> ok 6 sign should return a correct length RSA-PSS SHA-256 signature
> ok 7 sign should return a correct length RSA-PSS SHA-384 signature
> ok 8 sign should return a correct length RSA-PSS SHA-512 signature
> ok 9 verify should throw with non-private key
> ok 10 verify should return false with invalid signature
> ok 11 verify should return true with valid SHA-1 signature
> ok 12 verify should return true with valid SHA-256 signature
> ok 13 verify should return true with valid SHA-384 signature
> ok 14 verify should return true with valid SHA-512 signature
> ok 15 generateKey should throw with invalid usages # SKIP -
> ok 16 generateKey should return CryptoKey # SKIP -
> ok 17 generateKey should set public key type # SKIP -
> ok 18 generateKey should set private key type # SKIP -
> ok 19 generateKey should set public key algorithm # SKIP -
> ok 20 generateKey should set private key algorithm # SKIP -
> ok 21 generateKey should set public key algorithm name # SKIP -
> ok 22 generateKey should set private key algorithm name # SKIP -
> ok 23 generateKey should set public key algorithm hash name # SKIP -
> ok 24 generateKey should set private key algorithm hash name # SKIP -
> ok 25 generateKey should set public key extractable # SKIP -
> ok 26 generateKey should set private key extractable # SKIP -
> ok 27 generateKey should set public key usages # SKIP -
> ok 28 generateKey should set private key usages # SKIP -
> ok 29 generateKey should set public key handle # SKIP -
> ok 30 generateKey should set private key handle # SKIP -
> ok 31 importKey with "jwk" format private key and invalid usages should throw SyntaxError
> ok 32 importKey with "jwk" format non-private key and invalid usages should throw SyntaxError
> ok 33 importKey with "jwk" format invalid key type should throw DataError
> ok 34 importKey with "jwk" format invalid key use should throw DataError
> ok 35 importKey with "jwk" format PS1 key alg should set SHA-1 hash
> ok 36 importKey with "jwk" format PS256 key alg should set SHA-256 hash
> ok 37 importKey with "jwk" format PS384 key alg should set SHA-384 hash
> ok 38 importKey with "jwk" format PS512 key alg should set SHA-512 hash
> ok 39 importKey with "jwk" format invalid key alg should throw DataError
> ok 40 importKey with "jwk" format undefined key alg should not define hash # SKIP -
> ok 41 importKey with "jwk" format private RSA key should define type
> ok 42 importKey with "jwk" format private RSA key should define algorithm
> ok 43 importKey with "jwk" format private RSA key should define modulusLength
> ok 44 importKey with "jwk" format private RSA key should define publicExponent
> ok 45 importKey with "jwk" format private RSA key should define extractable
> ok 46 importKey with "jwk" format private RSA key should define usages
> ok 47 importKey with "jwk" format private RSA key should define handle
> ok 48 importKey with "jwk" format public RSA key should define type
> ok 49 importKey with "jwk" format public RSA key should define algorithm
> ok 50 importKey with "jwk" format public RSA key should define modulusLength
> ok 51 importKey with "jwk" format public RSA key should define publicExponent
> ok 52 importKey with "jwk" format public RSA key should define extractable
> ok 53 importKey with "jwk" format public RSA key should define usages
> ok 54 importKey with "jwk" format public RSA key should define handle
> ok 55 importKey with other format should throw NotSupportedError
> ok 56 exportKey with missing key material should throw OperationError
> ok 57 exportKey with "jwk" format SHA-1 hash should set "alg" to "PS1"
> ok 58 exportKey with "jwk" format SHA-256 hash should set "alg" to "PS256"
> ok 59 exportKey with "jwk" format SHA-384 hash should set "alg" to "PS384"
> ok 60 exportKey with "jwk" format SHA-512 hash should set "alg" to "PS512"
> ok 61 exportKey with other format should throw NotSupportedError
> # tests 42
> # pass 42
> # fail 0
> 1..61
> ok
> test/algorithms/RSASSA-PKCS1-v1_5_Spec.js .......
> ok 1 dictionaries getter should return an array # SKIP -
> ok 2 members getter should return an object # SKIP -
> ok 3 sign should throw with non-private key
> ok 4 sign should return an ArrayBuffer
> ok 5 sign should return a RSASSA-PKCS1-v1_5 SHA-1 signature
> ok 6 sign should return a RSASSA-PKCS1-v1_5 SHA-256 signature
> ok 7 sign should return a RSASSA-PKCS1-v1_5 SHA-384 signature
> ok 8 sign should return a RSASSA-PKCS1-v1_5 SHA-512 signature
> ok 9 verify should throw with non-private key
> ok 10 verify should return false with invalid signature
> ok 11 verify should return true with valid SHA-1 signature
> ok 12 verify should return true with valid SHA-256 signature
> ok 13 verify should return true with valid SHA-384 signature
> ok 14 verify should return true with valid SHA-512 signature
> ok 15 generateKey should throw with invalid usages # SKIP -
> ok 16 generateKey should return CryptoKey # SKIP -
> ok 17 generateKey should set public key type # SKIP -
> ok 18 generateKey should set private key type # SKIP -
> ok 19 generateKey should set public key algorithm # SKIP -
> ok 20 generateKey should set private key algorithm # SKIP -
> ok 21 generateKey should set public key algorithm name # SKIP -
> ok 22 generateKey should set private key algorithm name # SKIP -
> ok 23 generateKey should set public key algorithm hash name # SKIP -
> ok 24 generateKey should set private key algorithm hash name # SKIP -
> ok 25 generateKey should set public key extractable # SKIP -
> ok 26 generateKey should set private key extractable # SKIP -
> ok 27 generateKey should set public key usages # SKIP -
> ok 28 generateKey should set private key usages # SKIP -
> ok 29 generateKey should set public key handle # SKIP -
> ok 30 generateKey should set private key handle # SKIP -
> ok 31 importKey with "jwk" format private key and invalid usages should throw SyntaxError
> ok 32 importKey with "jwk" format non-private key and invalid usages should throw SyntaxError
> ok 33 importKey with "jwk" format invalid key type should throw DataError
> ok 34 importKey with "jwk" format invalid key use should throw DataError
> ok 35 importKey with "jwk" format RS1 key alg should set SHA-1 hash
> ok 36 importKey with "jwk" format RS256 key alg should set SHA-256 hash
> ok 37 importKey with "jwk" format RS384 key alg should set SHA-384 hash
> ok 38 importKey with "jwk" format RS512 key alg should set SHA-512 hash
> ok 39 importKey with "jwk" format invalid key alg should throw DataError
> ok 40 importKey with "jwk" format undefined key alg should not define hash # SKIP -
> ok 41 importKey with "jwk" format private RSA key should define type
> ok 42 importKey with "jwk" format private RSA key should define algorithm
> ok 43 importKey with "jwk" format private RSA key should define modulusLength
> ok 44 importKey with "jwk" format private RSA key should define publicExponent
> ok 45 importKey with "jwk" format private RSA key should define extractable
> ok 46 importKey with "jwk" format private RSA key should define usages
> ok 47 importKey with "jwk" format private RSA key should define handle
> ok 48 importKey with "jwk" format public RSA key should define type
> ok 49 importKey with "jwk" format public RSA key should define algorithm
> ok 50 importKey with "jwk" format public RSA key should define modulusLength
> ok 51 importKey with "jwk" format public RSA key should define publicExponent
> ok 52 importKey with "jwk" format public RSA key should define extractable
> ok 53 importKey with "jwk" format public RSA key should define usages
> ok 54 importKey with "jwk" format public RSA key should define handle
> ok 55 importKey with other format should throw NotSupportedError
> ok 56 exportKey with missing key material should throw OperationError
> ok 57 exportKey with "jwk" format SHA-1 hash should set "alg" to "RS1"
> ok 58 exportKey with "jwk" format SHA-256 hash should set "alg" to "RS256"
> ok 59 exportKey with "jwk" format SHA-384 hash should set "alg" to "RS384"
> ok 60 exportKey with "jwk" format SHA-512 hash should set "alg" to "RS512"
> ok 61 exportKey with other format should throw NotSupportedError
> # tests 42
> # pass 42
> # fail 0
> 1..61
> ok
> test/algorithms/RegisteredAlgorithmsSpec.js .....
> ok 1 RegisteredAlgorithms constructor should assign object argument properties
> ok 2 RegisteredAlgorithms getCaseInsensitive should match a known property with exact case
> ok 3 RegisteredAlgorithms getCaseInsensitive should match a known property with different case
> ok 4 RegisteredAlgorithms getCaseInsensitive should return "undefined" with no match
> # tests 4
> # pass 4
> # fail 0
> 1..4
> ok
> test/algorithms/SHASpec.js ......................
> ok 1 SHA dictionaries getter should return an array
> ok 2 SHA members getter should return an object
> ok 3 SHA digest should return an ArrayBuffer
> ok 4 SHA digest should return a SHA-1 digest
> ok 5 SHA digest should return a SHA-256 digest
> ok 6 SHA digest should return a SHA-384 digest
> ok 7 SHA digest should return a SHA-512 digest
> ok 8 SHA digest should throw an OperationError with unknown algorithm
> # tests 8
> # pass 8
> # fail 0
> 1..8
> ok
> test/algorithms/SupportedAlgorithmsSpec.js ......
> ok 1 SupportedAlgorithms constructor should initialize a container for each operation
> ok 2 SupportedAlgorithms operations should include specified operations
> ok 3 SupportedAlgorithms define should registered a type for an operation of an algorithm
> ok 4 SupportedAlgorithms normalize with string "alg" argument unknown algorithm should return an error
> ok 5 SupportedAlgorithms normalize with string "alg" argument valid algorithm should return the normalized algorithm
> ok 6 SupportedAlgorithms normalize with object "alg" argument invalid "name" should return an error
> ok 7 SupportedAlgorithms normalize with object "alg" argument unknown algorithm should return a NotSupportedError
> ok 8 SupportedAlgorithms normalize with object "alg" argument invalid param should return an error # SKIP -
> ok 9 SupportedAlgorithms normalize with object "alg" argument valid params should return the normalized algorithm
> # tests 8
> # pass 8
> # fail 0
> 1..9
> ok
> test/dictionaries/AlgorithmSpec.js ..............
> ok 1 Algorithm constructor with string "algorithm" argument should set instance name to argument value
> ok 2 Algorithm constructor with object "algorithm" argument should assign argument property values to instance
> ok 3 Algorithm constructor with object "algorithm" argument should require algorithm name to be a string
> # tests 3
> # pass 3
> # fail 0
> 1..3
> ok
> test/dictionaries/HmacKeyAlgorithmSpec.js ....... skipped: (no reason given)
> test/dictionaries/KeyAlgorithmSpec.js ...........
> ok 1 KeyAlgorithm constructor should assign argument property values to instance
> ok 2 KeyAlgorithm constructor should require algorithm name
> # tests 2
> # pass 2
> # fail 0
> 1..2
> ok
> test/dictionaries/RsaHashedKeyAlgorithmSpec.js .. skipped: (no reason given)
> test/dictionaries/ShaKeyAlgorithmSpec.js ........ skipped: (no reason given)
> test/keys/CryptoKeyPairSpec.js .................. skipped: (no reason given)
> test/keys/CryptoKeySpec.js ...................... skipped: (no reason given)
> test/keys/JsonWebKeySpec.js ..................... skipped: (no reason given)
> test/keys/recognizedKeyUsagesSpec.js ............
> ok 1 recognizedKeyUsages constructor should initialize the list
> ok 2 recognizedKeyUsages normalize should include recognized usages
> ok 3 recognizedKeyUsages normalize should ignore unknown usages
> # tests 3
> # pass 3
> # fail 0
> 1..3
> ok
>
> Test Summary Report
> -------------------
> test/EcdsaKeyPairsForTesting.js (Wstat: 256 Tests: 0 Failed: 0)
> Non-zero exit status: 1
> Parse errors: No plan found in TAP output
> test/algorithms/ECDSASpec.js (Wstat: 256 Tests: 0 Failed: 0)
> Non-zero exit status: 1
> Parse errors: No plan found in TAP output
> Files=27, Tests=584, 8 wallclock secs ( 0.09 usr 0.02 sys + 7.89 cusr 0.76 csys = 8.76 CPU)
> Result: FAIL
> make[1]: *** [debian/rules:18: override_dh_auto_test] Error 1
The full build log is available from:
http://qa-logs.debian.net/2021/12/20/node-trust-webcrypto_0.9.2-1_unstable.log
A list of current common problems and possible solutions is available at
http://wiki.debian.org/qa.debian.org/FTBFS . You're welcome to contribute!
If you reassign this bug to another package, please marking it as 'affects'-ing
this package. See https://www.debian.org/Bugs/server-control#affects
If you fail to reproduce this, please provide a build log and diff it with mine
so that we can identify if something relevant changed in the meantime.
More information about the Pkg-javascript-devel
mailing list