1Node.js for SDET — Start Here Before Playwright

1.1 Runtime model

Node is JavaScript + libuv (C event loop). One main thread runs your JS; libuv handles I/O on a thread pool. Callbacks/promises return to the main thread when work completes.

main thread:  parse JS → run sync code → await event loop
event loop:   timers → pending → poll (I/O) → check → close
thread pool:  fs reads, DNS, crypto (heavy)

1.2 Modules

// CommonJS (legacy default)
const fs = require('fs');
module.exports = { foo };

// ESM (modern)
import fs from 'node:fs/promises';
export { foo };
// Enable: package.json "type": "module" OR .mjs extension

// Dynamic import (works in both)
const mod = await import('./plugin.js');

1.3 package.json essentials

{
  "name": "my-tests",
  "version": "1.0.0",
  "type": "module",
  "main": "index.js",
  "scripts": {
    "test": "playwright test",
    "lint": "eslint .",
    "build": "tsc"
  },
  "dependencies":    { "axios": "^1.7.0" },
  "devDependencies": { "@playwright/test": "1.50.0", "vitest": "1.6.0" },
  "engines": { "node": ">=20" }
}

Version specifiers

• ^1.7.0 — compatible: 1.7.x, 1.8.x, … (up to next major)
• ~1.7.0 — patch only: 1.7.x
• 1.7.0 — exact
• * — any

1.4 npm vs yarn vs pnpm

1.5 Async patterns evolution

// 1. Callbacks (legacy)
fs.readFile('a.txt', 'utf8', (err, data) => {
  if (err) return console.error(err);
  console.log(data);
});

// 2. Promises (Node 10+)
fs.promises.readFile('a.txt', 'utf8').then(console.log).catch(console.error);

// 3. async/await (modern default)
async function read() {
  try {
    const data = await fs.promises.readFile('a.txt', 'utf8');
    console.log(data);
  } catch (e) { console.error(e); }
}

// 4. Streams (for large data)
const stream = fs.createReadStream('big.csv');
for await (const chunk of stream) process(chunk);

1.6 Useful core modules

// fs (filesystem)
import { readFile, writeFile, mkdir, readdir, stat } from 'node:fs/promises';

// path — cross-platform paths
import path from 'node:path';
path.join('a', 'b', 'c.txt');           // 'a/b/c.txt' or 'a\\b\\c.txt' on Windows
path.resolve(import.meta.dirname, 'data.json');

// http — built-in HTTP server / client
import http from 'node:http';
http.createServer((req, res) => res.end('ok')).listen(3000);

// child_process — run external commands
import { execSync, spawn } from 'node:child_process';
const out = execSync('git rev-parse HEAD').toString().trim();
const proc = spawn('npm', ['test'], { stdio: 'inherit' });

// crypto
import { randomUUID, createHash } from 'node:crypto';
const id = randomUUID();
const hash = createHash('sha256').update('x').digest('hex');

// util
import { promisify, inspect } from 'node:util';
const sleep = promisify(setTimeout);
await sleep(1000);
console.log(inspect(obj, { depth: 4, colors: true }));

1.7 Minimal Express server

import express from 'express';

const app = express();
app.use(express.json());

const users = [{ id: 1, name: 'Alice' }];

app.get('/users', (req, res) => res.json(users));
app.post('/users', (req, res) => {
  const u = { id: Date.now(), ...req.body };
  users.push(u);
  res.status(201).json(u);
});

app.use((err, req, res, next) => res.status(500).json({ error: err.message }));

app.listen(3000, () => console.log('listening on 3000'));

1.8 Workers + cluster

• Worker Threads — true parallel JS on multiple cores. Use for CPU-heavy work (image processing, hashing).
• Cluster — fork the main process; each worker handles connections. Built into Node; PM2 / production frameworks use it under the hood.

// Worker
import { Worker } from 'node:worker_threads';
const w = new Worker('./hash-worker.js', { workerData: { input: 'big' }});
w.on('message', (hash) => console.log(hash));

1.9 Debugging + memory

node --inspect-brk app.js              # opens chrome://inspect debugger
node --max-old-space-size=4096 app.js  # raise heap to 4GB

# Heap snapshot
kill -SIGUSR2 <pid>                    # writes heapdump
# Open in Chrome DevTools → Memory → Load

# Profile
node --prof app.js
node --prof-process isolate-0x*.log