آموزش رایگان Node.js در ویندوز؛ از نصب تا ساخت API

import test from 'node:test';
import assert from 'node:assert/strict';
import { once } from 'node:events';
import { request } from 'node:http';
import { makeServer } from './app.mjs';
import { makeStore } from './model.mjs';

async function withServer(run) {
  const server = makeServer();
  server.listen(0, '127.0.0.1');
  await once(server, 'listening');
  const base = `http://127.0.0.1:${server.address().port}`;
  try { await run(base); }
  finally { await new Promise(resolve => server.close(resolve)); }
}
const post = (base, body, headers = { 'Content-Type': 'application/json' }) =>
  fetch(`${base}/tasks`, { method: 'POST', headers, body });

test('health, JSON type and no-store', () => withServer(async base => {
  const response = await fetch(`${base}/health`);
  assert.equal(response.status, 200);
  assert.match(response.headers.get('content-type'), /application\/json/);
  assert.equal(response.headers.get('cache-control'), 'no-store');
  assert.deepEqual(await response.json(), { ok: true });
}));
test('new server starts with empty list', () => withServer(async base => {
  assert.deepEqual(await (await fetch(`${base}/tasks`)).json(), { tasks: [] });
}));
test('create, list, read and update a Persian task', () => withServer(async base => {
  const created = await post(base, JSON.stringify({ title: '  یادگیری سرور  ' }));
  assert.equal(created.status, 201);
  const { task } = await created.json();
  assert.equal(task.title, 'یادگیری سرور');
  assert.equal(task.done, false);
  assert.match(task.id, /^[0-9a-f-]{36}$/);
  assert.equal(created.headers.get('location'), `/tasks/${task.id}`);
  assert.deepEqual((await (await fetch(base + created.headers.get('location'))).json()).task, task);
  const changed = await fetch(`${base}/tasks/${task.id}`, {
    method: 'PATCH', headers: { 'Content-Type': 'application/json' }, body: '{"done":true}'
  });
  assert.equal(changed.status, 200);
  assert.equal((await changed.json()).task.done, true);
  assert.equal((await (await fetch(`${base}/tasks`)).json()).tasks[0].done, true);
}));
test('malformed JSON is 400 and does not create data', () => withServer(async base => {
  assert.equal((await post(base, '{')).status, 400);
  assert.deepEqual(await (await fetch(`${base}/tasks`)).json(), { tasks: [] });
}));
test('empty JSON body is 400', () => withServer(async base => {
  assert.equal((await post(base, '')).status, 400);
}));
test('invalid UTF-8 is 400', () => withServer(async base => {
  assert.equal((await post(base, Buffer.from([0xff]))).status, 400);
}));
test('wrong content type is 415', () => withServer(async base => {
  assert.equal((await post(base, '{"title":"hello"}', { 'Content-Type': 'text/plain' })).status, 415);
}));
test('compressed body is outside this contract', () => withServer(async base => {
  assert.equal((await post(base, '{}', {
    'Content-Type': 'application/json', 'Content-Encoding': 'gzip'
  })).status, 415);
}));
test('body limit is bytes, including multibyte Persian', () => withServer(async base => {
  const body = JSON.stringify({ title: 'س'.repeat(5000) });
  assert.ok(Buffer.byteLength(body) > 8192);
  assert.equal((await post(base, body)).status, 413);
}));
test('chunked oversized body receives 413 JSON', () => withServer(base => new Promise((resolve, reject) => {
  const req = request(`${base}/tasks`, {
    method: 'POST', headers: { 'Content-Type': 'application/json' }
  }, response => {
    let body = '';
    response.setEncoding('utf8');
    response.on('data', chunk => { body += chunk; });
    response.on('end', () => {
      try {
        assert.equal(response.statusCode, 413);
        assert.equal(JSON.parse(body).error, 'BODY_TOO_LARGE');
        resolve();
      } catch (error) { reject(error); }
    });
  });
  req.on('error', reject);
  req.write('x'.repeat(5000));
  req.end('x'.repeat(5000));
})));
for (const [name, input] of [
  ['array', []], ['null', null], ['number title', { title: 42 }],
  ['blank title', { title: '   ' }], ['long title', { title: 'x'.repeat(101) }],
  ['extra field', { title: 'hello', admin: true }]
]) {
  test(`reject ${name} with 422`, () => withServer(async base => {
    assert.equal((await post(base, JSON.stringify(input))).status, 422);
  }));
}
test('unknown route is 404', () => withServer(async base => {
  assert.equal((await fetch(`${base}/unknown`)).status, 404);
}));
test('unsupported method has 405 and Allow header', () => withServer(async base => {
  const response = await fetch(`${base}/tasks`, { method: 'DELETE' });
  assert.equal(response.status, 405);
  assert.equal(response.headers.get('allow'), 'GET, POST');
}));
test('missing task is 404', () => withServer(async base => {
  assert.equal((await fetch(`${base}/tasks/00000000-0000-0000-0000-000000000000`)).status, 404);
}));
test('done must be boolean, rejected update preserves task', () => withServer(async base => {
  const { task } = await (await post(base, '{"title":"hello"}')).json();
  const response = await fetch(`${base}/tasks/${task.id}`, {
    method: 'PATCH', headers: { 'Content-Type': 'application/json' }, body: '{"done":"true"}'
  });
  assert.equal(response.status, 422);
  assert.equal((await (await fetch(`${base}/tasks/${task.id}`)).json()).task.done, false);
}));
test('each server owns its own in-memory state', async () => {
  await withServer(async base => { assert.equal((await post(base, '{"title":"hello"}')).status, 201); });
  await withServer(async base => { assert.deepEqual(await (await fetch(`${base}/tasks`)).json(), { tasks: [] }); });
});
test('store returns copies and enforces maximum count', () => {
  const store = makeStore();
  const first = store.create({ title: 'hello' });
  first.title = 'changed outside';
  assert.equal(store.get(first.id).title, 'hello');
  const list = store.list(); list[0].done = true;
  assert.equal(store.get(first.id).done, false);
  for (let i = 1; i < 1000; i++) store.create({ title: `task ${i}` });
  assert.throws(() => store.create({ title: 'overflow' }), error => error.status === 409);
});

npm.cmd run check
npm.cmd test