Thream/socketio-jwt
Archived
2
1
Fork 0
Code Issues Pull Requests Releases Activity

refactor: usage of node:test instead of tap

Browse Source
This commit is contained in:
Théo LUDWIG 2023-07-22 12:18:28 +02:00
parent b708d66586
commit 50c236ca4d
Signed by: theoludwig
GPG Key ID: ADFE5A563D718F3B
11 changed files with 1294 additions and 4782 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.eslintrc.json
View File

@ -1,6 +1,7 @@
{
"extends": ["conventions", "prettier"],
"plugins": ["prettier", "import", "unicorn"],
"parser": "@typescript-eslint/parser",
"parserOptions": {
"project": "./tsconfig.json"
},

2
.github/workflows/build.yml vendored
View File

@ -15,7 +15,7 @@ jobs:
- name: 'Setup Node.js'
uses: 'actions/setup-node@v3.6.0'
with:
node-version: 'lts/*'
node-version: '20.x'
cache: 'npm'
- name: 'Install dependencies'

2
.github/workflows/lint.yml vendored
View File

@ -15,7 +15,7 @@ jobs:
- name: 'Setup Node.js'
uses: 'actions/setup-node@v3.6.0'
with:
node-version: 'lts/*'
node-version: '20.x'
cache: 'npm'
- name: 'Install dependencies'

2
.github/workflows/release.yml vendored
View File

@ -18,7 +18,7 @@ jobs:
- name: 'Setup Node.js'
uses: 'actions/setup-node@v3.6.0'
with:
node-version: 'lts/*'
node-version: '20.x'
cache: 'npm'
- name: 'Install dependencies'

2
.github/workflows/test.yml vendored
View File

@ -15,7 +15,7 @@ jobs:
- name: 'Setup Node.js'
uses: 'actions/setup-node@v3.6.0'
with:
node-version: 'lts/*'
node-version: '20.x'
cache: 'npm'
- name: 'Install dependencies'

5
.nycrc.json
View File

@ -1,5 +0,0 @@
{
"reporter": ["text", "cobertura"],
"src": "./build",
"all": true
}

1
.swcrc
View File

@ -1,4 +1,5 @@
{
"sourceMaps": true,
"jsc": {
"parser": {
"syntax": "typescript",

9
.taprc
View File

@ -1,9 +0,0 @@
ts: false
jsx: false
flow: false
check-coverage: false
coverage: false
timeout: 10000
files:
- 'build/**/*.test.js'

5822
package-lock.json generated
View File

File diff suppressed because it is too large Load Diff

37
package.json
View File

@ -10,7 +10,8 @@
"files": [
"build",
"!**/*.test.js",
"!**/*.test.d.ts"
"!**/*.test.d.ts",
"!**/*.map"
],
"engines": {
"node": ">=16.0.0",
@ -44,7 +45,7 @@
"lint:eslint": "eslint . --ignore-path .gitignore",
"lint:prettier": "prettier . --check --ignore-path .gitignore",
"lint:staged": "lint-staged",
"test": "c8 tap",
"test": "cross-env NODE_ENV=test node --enable-source-maps --test build/",
"release": "semantic-release",
"postinstall": "husky install",
"prepublishOnly": "pinst --disable",
@ -57,38 +58,36 @@
"jsonwebtoken": "9.0.0"
},
"devDependencies": {
"@commitlint/cli": "17.6.6",
"@commitlint/config-conventional": "17.6.6",
"@commitlint/cli": "17.6.7",
"@commitlint/config-conventional": "17.6.7",
"@swc/cli": "0.1.62",
"@swc/core": "1.3.67",
"@swc/core": "1.3.70",
"@tsconfig/strictest": "2.0.1",
"@types/jsonwebtoken": "9.0.2",
"@types/node": "20.3.3",
"@types/tap": "15.0.8",
"@typescript-eslint/eslint-plugin": "5.60.1",
"@typescript-eslint/parser": "5.60.1",
"@types/node": "20.4.3",
"@typescript-eslint/eslint-plugin": "6.1.0",
"@typescript-eslint/parser": "6.1.0",
"axios": "1.4.0",
"c8": "8.0.0",
"cross-env": "7.0.3",
"editorconfig-checker": "5.1.1",
"eslint": "8.44.0",
"eslint-config-conventions": "10.0.0",
"eslint": "8.45.0",
"eslint-config-conventions": "11.0.1",
"eslint-config-prettier": "8.8.0",
"eslint-plugin-import": "2.27.5",
"eslint-plugin-prettier": "4.2.1",
"eslint-plugin-prettier": "5.0.0",
"eslint-plugin-promise": "6.1.1",
"eslint-plugin-unicorn": "47.0.0",
"fastify": "4.19.1",
"eslint-plugin-unicorn": "48.0.0",
"fastify": "4.20.0",
"husky": "8.0.3",
"lint-staged": "13.2.3",
"markdownlint-cli2": "0.8.1",
"markdownlint-rule-relative-links": "2.1.0",
"pinst": "3.0.0",
"prettier": "2.8.8",
"prettier": "3.0.0",
"rimraf": "5.0.1",
"semantic-release": "21.0.6",
"semantic-release": "21.0.7",
"socket.io": "4.7.1",
"socket.io-client": "4.7.1",
"tap": "16.3.7",
"typescript": "5.0.4"
"typescript": "5.1.6"
}
}

191
src/__test__/authorize.test.ts
View File

@ -1,4 +1,6 @@
import tap from 'tap'
import test from 'node:test'
import assert from 'node:assert/strict'
import axios from 'axios'
import type { Socket } from 'socket.io-client'
import { io } from 'socket.io-client'
@ -24,7 +26,7 @@ const secretCallback = async (): Promise<string> => {
return 'somesecret'
}
await tap.test('authorize', async (t) => {
await test('authorize', async (t) => {
await t.test('with secret as string in options', async (t) => {
let token = ''
let socket: Socket | null = null
@ -40,71 +42,76 @@ await tap.test('authorize', async (t) => {
await fixtureStop()
})
await t.test('should emit error with no token provided', (t) => {
t.plan(4)
await t.test('should emit error with no token provided', () => {
socket = io(API_URL)
socket.on('connect_error', async (error) => {
t.equal(isUnauthorizedError(error), true)
assert.strictEqual(isUnauthorizedError(error), true)
if (isUnauthorizedError(error)) {
t.equal(error.data.message, 'no token provided')
t.equal(error.data.code, 'credentials_required')
assert.strictEqual(error.data.message, 'no token provided')
assert.strictEqual(error.data.code, 'credentials_required')
assert.ok(true)
} else {
assert.fail('should be unauthorized error')
}
t.pass()
})
socket.on('connect', async () => {
t.fail()
assert.fail('should not connect')
})
})
await t.test('should emit error with bad token format', (t) => {
t.plan(4)
await t.test('should emit error with bad token format', () => {
socket = io(API_URL, {
auth: { token: 'testing' }
})
socket.on('connect_error', async (error) => {
t.equal(isUnauthorizedError(error), true)
assert.strictEqual(isUnauthorizedError(error), true)
if (isUnauthorizedError(error)) {
t.equal(error.data.message, 'Format is Authorization: Bearer [token]')
t.equal(error.data.code, 'credentials_bad_format')
assert.strictEqual(
error.data.message,
'Format is Authorization: Bearer [token]'
)
assert.strictEqual(error.data.code, 'credentials_bad_format')
assert.ok(true)
} else {
assert.fail('should be unauthorized error')
}
t.pass()
})
socket.on('connect', async () => {
t.fail()
assert.fail('should not connect')
})
})
await t.test('should emit error with unauthorized handshake', (t) => {
t.plan(4)
await t.test('should emit error with unauthorized handshake', () => {
socket = io(API_URL, {
auth: { token: 'Bearer testing' }
})
socket.on('connect_error', async (error) => {
t.equal(isUnauthorizedError(error), true)
assert.strictEqual(isUnauthorizedError(error), true)
if (isUnauthorizedError(error)) {
t.equal(
assert.strictEqual(
error.data.message,
'Unauthorized: Token is missing or invalid Bearer'
)
t.equal(error.data.code, 'invalid_token')
assert.strictEqual(error.data.code, 'invalid_token')
assert.ok(true)
} else {
assert.fail('should be unauthorized error')
}
t.pass()
})
socket.on('connect', async () => {
t.fail()
assert.fail('should not connect')
})
})
await t.test('should connect the user', (t) => {
t.plan(1)
await t.test('should connect the user', () => {
socket = io(API_URL, {
auth: { token: `Bearer ${token}` }
})
socket.on('connect', async () => {
t.pass()
assert.ok(true)
})
socket.on('connect_error', async (error) => {
t.fail(error.message)
assert.fail(error.message)
})
})
})
@ -124,71 +131,76 @@ await tap.test('authorize', async (t) => {
await fixtureStop()
})
await t.test('should emit error with no token provided', (t) => {
t.plan(4)
await t.test('should emit error with no token provided', () => {
socket = io(API_URL)
socket.on('connect_error', async (error) => {
t.equal(isUnauthorizedError(error), true)
assert.strictEqual(isUnauthorizedError(error), true)
if (isUnauthorizedError(error)) {
t.equal(error.data.message, 'no token provided')
t.equal(error.data.code, 'credentials_required')
assert.strictEqual(error.data.message, 'no token provided')
assert.strictEqual(error.data.code, 'credentials_required')
assert.ok(true)
} else {
assert.fail('should be unauthorized error')
}
t.pass()
})
socket.on('connect', async () => {
t.fail()
assert.fail('should not connect')
})
})
await t.test('should emit error with bad token format', (t) => {
t.plan(4)
await t.test('should emit error with bad token format', () => {
socket = io(API_URL, {
auth: { token: 'testing' }
})
socket.on('connect_error', async (error) => {
t.equal(isUnauthorizedError(error), true)
assert.strictEqual(isUnauthorizedError(error), true)
if (isUnauthorizedError(error)) {
t.equal(error.data.message, 'Format is Authorization: Bearer [token]')
t.equal(error.data.code, 'credentials_bad_format')
assert.strictEqual(
error.data.message,
'Format is Authorization: Bearer [token]'
)
assert.strictEqual(error.data.code, 'credentials_bad_format')
assert.ok(true)
} else {
assert.fail('should be unauthorized error')
}
t.pass()
})
socket.on('connect', async () => {
t.fail()
assert.fail('should not connect')
})
})
await t.test('should emit error with unauthorized handshake', (t) => {
t.plan(4)
await t.test('should emit error with unauthorized handshake', () => {
socket = io(API_URL, {
auth: { token: 'Bearer testing' }
})
socket.on('connect_error', async (error) => {
t.equal(isUnauthorizedError(error), true)
assert.strictEqual(isUnauthorizedError(error), true)
if (isUnauthorizedError(error)) {
t.equal(
assert.strictEqual(
error.data.message,
'Unauthorized: Token is missing or invalid Bearer'
)
t.equal(error.data.code, 'invalid_token')
assert.strictEqual(error.data.code, 'invalid_token')
assert.ok(true)
} else {
assert.fail('should be unauthorized error')
}
t.pass()
})
socket.on('connect', async () => {
t.fail()
assert.fail('should not connect')
})
})
await t.test('should connect the user', (t) => {
t.plan(1)
await t.test('should connect the user', () => {
socket = io(API_URL, {
auth: { token: `Bearer ${token}` }
})
socket.on('connect', async () => {
t.pass()
assert.ok(true)
})
socket.on('connect_error', async (error) => {
t.fail(error.message)
assert.fail(error.message)
})
})
})
@ -221,104 +233,107 @@ await tap.test('authorize', async (t) => {
await fixtureStop()
})
await t.test('should emit error with no token provided', (t) => {
t.plan(4)
await t.test('should emit error with no token provided', () => {
socket = io(API_URL)
socket.on('connect_error', async (error) => {
t.equal(isUnauthorizedError(error), true)
assert.strictEqual(isUnauthorizedError(error), true)
if (isUnauthorizedError(error)) {
t.equal(error.data.message, 'no token provided')
t.equal(error.data.code, 'credentials_required')
assert.strictEqual(error.data.message, 'no token provided')
assert.strictEqual(error.data.code, 'credentials_required')
assert.ok(true)
} else {
assert.fail('should be unauthorized error')
}
t.pass()
})
socket.on('connect', async () => {
t.fail()
assert.fail('should not connect')
})
})
await t.test('should emit error with bad token format', (t) => {
t.plan(4)
await t.test('should emit error with bad token format', () => {
socket = io(API_URL, {
auth: { token: 'testing' }
})
socket.on('connect_error', async (error) => {
t.equal(isUnauthorizedError(error), true)
assert.strictEqual(isUnauthorizedError(error), true)
if (isUnauthorizedError(error)) {
t.equal(error.data.message, 'Format is Authorization: Bearer [token]')
t.equal(error.data.code, 'credentials_bad_format')
assert.strictEqual(
error.data.message,
'Format is Authorization: Bearer [token]'
)
assert.strictEqual(error.data.code, 'credentials_bad_format')
assert.ok(true)
} else {
assert.fail('should be unauthorized error')
}
t.pass()
})
socket.on('connect', async () => {
t.fail()
assert.fail('should not connect')
})
})
await t.test('should emit error with unauthorized handshake', (t) => {
t.plan(4)
await t.test('should emit error with unauthorized handshake', () => {
socket = io(API_URL, {
auth: { token: 'Bearer testing' }
})
socket.on('connect_error', async (error) => {
t.equal(isUnauthorizedError(error), true)
assert.strictEqual(isUnauthorizedError(error), true)
if (isUnauthorizedError(error)) {
t.equal(
assert.strictEqual(
error.data.message,
'Unauthorized: Token is missing or invalid Bearer'
)
t.equal(error.data.code, 'invalid_token')
assert.strictEqual(error.data.code, 'invalid_token')
assert.ok(true)
} else {
assert.fail('should be unauthorized error')
}
t.pass()
})
socket.on('connect', async () => {
t.fail()
assert.fail('should not connect')
})
})
await t.test('should connect the user', (t) => {
t.plan(1)
await t.test('should connect the user', () => {
socket = io(API_URL, {
auth: { token: `Bearer ${token}` }
})
socket.on('connect', async () => {
t.pass()
assert.ok(true)
})
socket.on('connect_error', async (error) => {
t.fail(error.message)
assert.fail(error.message)
})
})
await t.test('should contains user properties', (t) => {
t.plan(2)
await t.test('should contains user properties', () => {
const socketServer = getSocket()
socketServer?.on('connection', (client: any) => {
t.equal(client.user.email, basicProfile.email)
t.pass()
assert.strictEqual(client.user.email, basicProfile.email)
assert.ok(true)
})
socket = io(API_URL, {
auth: { token: `Bearer ${token}` }
})
socket.on('connect_error', async (error) => {
t.fail(error.message)
assert.fail(error.message)
})
})
await t.test('should emit error when user validation fails', (t) => {
t.plan(2)
await t.test('should emit error when user validation fails', () => {
socket = io(API_URL, {
auth: { token: `Bearer ${wrongToken}` }
})
socket.on('connect_error', async (error) => {
try {
t.equal(error.message, 'Check Field validation failed')
t.pass()
assert.strictEqual(error.message, 'Check Field validation failed')
assert.ok(true)
} catch {
t.fail()
assert.fail(error.message)
}
})
socket.on('connect', async () => {
t.fail()
assert.fail('should not connect')
})
})
})