Vai al contenuto
KendorDocs

Come costruire un take-home con un database reale

Dai ai candidati un'istanza reale di PostgreSQL, MySQL, MongoDB o Valkey, popolala con un piccolo file SQL e scrivi test che la usano davvero. Niente mock, niente configurazione locale.

Un take-home con un database funziona meglio quando il candidato riceve un database reale già in esecuzione e popolato, così il tempo va nel compito e non nella configurazione. Mantieni piccoli lo schema e i dati di seed, scrivi alcuni test che girano sul database reale e assicurati che l'ambiente parta allo stesso modo per ogni candidato.

Perché usare un database reale invece dei mock?

La maggior parte dei bug backend vive al confine tra codice e dati: un indice mancante, una query che restituisce duplicati dopo una join, una transazione che non lo è, una cache che diventa obsoleta. Un repository simulato nasconde tutto questo. Con un database reale il candidato deve affrontare gli stessi problemi che porterà il lavoro.

Un database reale cambia anche cosa puoi chiedere:

  • Scrivere una migrazione che aggiunge una colonna senza perdere dati.
  • Correggere una query lenta e mostrare il piano della query prima e dopo.
  • Rendere un endpoint sicuro in caso di concorrenza con una transazione o un lock.
  • Aggiungere una cache davanti a una lettura frequente e invalidarla correttamente.

Nulla di tutto questo ha senso con un finto in memoria.

Il costo di configurazione è il vero rischio

L'obiezione classica è la configurazione. Chiedere ai candidati di installare PostgreSQL, creare un ruolo e caricare un dump costa loro un'ora prima di scrivere una riga, e quell'ora favorisce chi ha il portatile giusto. Qualunque strumento tu usi, il database dovrebbe essere in esecuzione quando il candidato apre il progetto.

Popolalo con un dataset piccolo e mirato

I dati di seed fanno parte del design del compito. Alcune regole:

  • Abbastanza piccolo da leggere. Dieci clienti e quaranta ordini permettono al candidato di capire i dati con una sola SELECT. Un milione di righe generate hanno senso solo se il compito riguarda le prestazioni.
  • Modellato sul compito. Se il bug riguarda ordini senza articoli, assicurati che il seed ne contenga uno. Se il compito è la paginazione, popola abbastanza righe per tre pagine.
  • Prima lo schema, poi i dati. Dividili in due file, 001_schema.sql e 002_seed.sql, così il candidato trova rapidamente le definizioni delle tabelle.
  • Nessun dato reale dei clienti. Usa nomi e indirizzi inventati, anche per un'assunzione interna.

Se il tuo progetto ha già delle migrazioni (Prisma, Alembic, Django, Laravel), lascia che sia il passo di installazione a eseguirle e tieni il file di seed solo per i dati.

Quanto dovrebbe essere grande il compito?

Punta a qualcosa che puoi completare in metà del limite di tempo. I compiti sui database richiedono più tempo di quanto sembri, perché il candidato deve prima esplorare lo schema. Una modifica mirata, come un endpoint, una migrazione o una correzione di query, più i test, è più che sufficiente per 90 minuti.

Scrivi test che usano il database

I test dicono al candidato cosa significa "fatto" e gli permettono di controllare il proprio lavoro. Per un compito sul database dovrebbero girare sullo stesso database usato dall'app.

  • Leggi la connessione dall'ambiente, per esempio DATABASE_URL, mai una stringa scritta nel codice.
  • Ripulisci dopo ogni test. Racchiudi ciascuno in una transazione e fai il rollback, oppure elimina le righe che ha creato. Il database conserva le sue righe mentre il candidato lavora, quindi i test che lasciano dati dietro di sé falliranno la seconda volta che vengono eseguiti.
  • Testa il comportamento, non l'SQL. Verifica ciò che restituisce l'endpoint o ciò che finisce nella tabella, così qualsiasi soluzione corretta passa.
test/orders.test.js
const { test } = require('node:test');
const assert = require('node:assert');
const { Client } = require('pg');

test('an order with no items has a zero total', async () => {
  const db = new Client({ connectionString: process.env.DATABASE_URL });
  await db.connect();
  await db.query('BEGIN');

  const { rows } = await db.query(
    "INSERT INTO orders (customer_id) VALUES (1) RETURNING id",
  );
  const total = await db.query('SELECT order_total($1) AS total', [rows[0].id]);
  assert.strictEqual(Number(total.rows[0].total), 0);

  await db.query('ROLLBACK');
  await db.end();
});

Suggerimento. Consegna un test che passa e uno che fallisce e che descrive il compito. Il candidato vede subito come girano i test e cosa resta da fare.

Conviene aggiungere una cache o una coda?

Solo se il compito riguarda quello. Un archivio compatibile con Redis ha senso per un rate limiter, un session store o un problema di invalidazione della cache. Aggiungerne uno "per realismo" aggiunge solo una seconda cosa da capire in poco tempo.

Come farlo in Kendor

Kendor esegue PostgreSQL, MySQL, MongoDB e Valkey (compatibile con Redis) dentro la sandbox del candidato, su 127.0.0.1. Partono prima dei tuoi comandi di installazione, quindi le migrazioni possono girare durante l'installazione. Li dichiari in kendor.yaml nella radice del progetto. Riferimento completo in Database.

kendor.yaml
version: 1
runtime:
  type: node
  version: "22"
databases:
  - type: postgres
    version: "18"
    init: db
  - type: valkey
    version: "9"
install:
  commands:
    - npm ci
services:
  api:
    dev:
      command: node --watch src/server.js
      port: 3000
    test:
      command: node --test
preview:
  service: api

Cosa fa ciascuna parte:

  • databases elenca al massimo uno per tipo, e al massimo un database SQL (PostgreSQL o MySQL). Sono disponibili PostgreSQL 18, MySQL 8.4, MongoDB 8.0 e Valkey 9.
  • init è un file di seed, oppure una cartella i cui file di seed vengono eseguiti in ordine alfabetico: .sql per PostgreSQL e MySQL, .js per MongoDB. Gira una volta, subito dopo la creazione del database; su PostgreSQL, come un'unica transazione. Deve essere un percorso all'interno del progetto. Valkey non accetta init; popolalo dall'app o dalla configurazione dei test.
  • name (facoltativo, non per Valkey) imposta il nome del database. Il valore predefinito è app.

Ogni processo nella sandbox, compresi app, terminali e test, riceve i dettagli di connessione: DATABASE_URL, PGHOST, PGPORT, PGUSER e PGDATABASE per PostgreSQL, DATABASE_URL, MYSQL_HOST e simili per MySQL, MONGODB_URI per MongoDB, e REDIS_URL e VALKEY_URL per Valkey. Vengono impostate anche le variabili di Laravel e Spring (DB_HOST, SPRING_DATASOURCE_URL e così via). I candidati possono aprire psql, mysql, mongosh o redis-cli nel terminale per guardare dentro, e i database non sono raggiungibili dall'esterno della sandbox.

Configuralo dall'editor

Se preferisci non scrivere YAML, apri la sfida nell'editor e usa la Configurazione runtime. In Database, scegli il motore e la versione e punta File di seed al tuo SQL. Passa a YAML grezzo per vedere cosa ha scritto. Quando importi un repository, Kendor spesso rileva il database da solo, da uno schema Prisma, un docker-compose.yml o le dipendenze del progetto, e lo precompila.

Verificalo come candidato

Scegli Anteprima come candidato ed esegui i test dalla scheda Test. La scheda Test esegue il comando test di kendor.yaml; l'output TAP (node --test, pytest --tap-stream) produce una riga per test. Vedi La scheda Test.

Nota. Le righe del database restano mentre il candidato lavora, anche dopo il riavvio della sandbox. Non vengono però salvate con la consegna: ciò che rivedi è il codice, comprese le migrazioni e i file di seed che il candidato ha modificato.

Questo articolo ti è stato utile?