The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
---
title: Testare
description: Configurare Vitest, teste de integrare pe un server Twenty real, verificare a tipurilor și CI cu GitHub Actions.
---
import { PageBanner } from "/snippets/page-banner.mdx"
## Prezentare generală
Folosește CLI-ul autonom cu `--json` pentru a construi, publica, instala și dezinstala aplicația din codul de test. Instalează-l global cu `npm install -g twenty`. Combinat cu [Vitest](https://vitest.dev/) și clienții API tipizați, puteți scrie teste de integrare care verifică faptul că aplicația funcționează de la un cap la altul pe un server Twenty real.
## Utilizarea pachetelor npm
Puteți instala și utiliza orice pachet npm în aplicația dvs. Atât funcţiile logice cât şi componentele frontale sunt grupate cu [esbuild](https://esbuild.github.io/), care înglobează dependențele lor la ieșire - nu sunt necesare `node_modules` în timpul rulării.
### Instalarea unui pachet
```bash filename="Terminal"
yarn add axios
```
Apoi importați-l în codul dvs.:
```ts src/logic-functions/fetch-data.ts
import { defineLogicFunction } from 'twenty-sdk/define';
import axios from 'axios';
const handler = async () => {
const { data } = await axios.get('https://api.example.com/data');
return { data };
};
export default defineLogicFunction({
universalIdentifier: '...',
name: 'fetch-data',
description: 'Fetches data from an external API',
timeoutSeconds: 10,
handler,
});
```
Același lucru funcționează și pentru componentele frontend:
```tsx src/front-components/chart.tsx
import { defineFrontComponent } from 'twenty-sdk/define';
import { format } from 'date-fns';
const DateWidget = () => {
return <p>Today is {format(new Date(), 'MMMM do, yyyy')}</p>;
};
export default defineFrontComponent({
universalIdentifier: '...',
name: 'date-widget',
component: DateWidget,
});
```
### Cum funcționează împachetarea
Pasul de build folosește esbuild pentru a produce un singur fișier autonom pentru fiecare funcție logică și pentru fiecare componentă frontend. Ambalajele importate sunt încorporate în pachet, cu excepţia celor enumerate mai jos.
**Funcțiile logice** rulează într-un mediu Node.js. Modulele built-in Node (`fs`, `path`, `crypto`, `http` etc.) sunt disponibile și nu trebuie instalate.
**Componentele frontend** rulează într-un Web Worker. Modulele built-in Node **nu** sunt disponibile — doar pachetele npm care funcționează într-un mediu de browser. Reține că sandbox-ul implementează un DOM *parțial*, astfel încât un pachet se poate construi fără erori, dar totuși poate eșua la execuție; vezi [Limitări curente](/ro/developers/extend/apps/layout/front-components#current-limitations).
Ambele medii au `twenty-client-sdk/core` și `twenty-client-sdk/metadata` disponibile ca module pre-furnizate — acestea nu sunt incluse în bundle, ci sunt rezolvate la rulare de către server.
Componentele frontului pot de asemenea partaja dependențe printr-un [pachet de dependențe partajate](/ro/developers/extend/apps/layout/front-components#sharing-dependencies-across-front-components). Pachete listate în câmpul `frontComponentSharedDependencies` din pachetul aplicației. Fiul este construit o dată într-un fișier separat și încărcat din el la rulare în loc să fie înglobat în fiecare componentă, astfel încât o componentă care importă numai pachete comune să nu aibă aproape niciun cod propriu de dependență.
## Configurare
Aplicația generată (scaffolded) include deja Vitest. Dacă o configurați manual, instalați dependențele:
```bash filename="Terminal"
yarn add -D vitest vite-tsconfig-paths
```
Creați un `vitest.config.ts` în rădăcina aplicației:
```ts vitest.config.ts
import tsconfigPaths from 'vite-tsconfig-paths';
import { defineConfig } from 'vitest/config';
const TWENTY_API_URL = process.env.TWENTY_API_URL ?? 'http://localhost:2020';
const TWENTY_API_KEY =
process.env.TWENTY_API_KEY ?? '<the pre-seeded local dev key>';
// Make env vars available to globalSetup (test.env only applies to workers)
process.env.TWENTY_API_URL = TWENTY_API_URL;
process.env.TWENTY_API_KEY = TWENTY_API_KEY;
export default defineConfig({
plugins: [
tsconfigPaths({
projects: ['tsconfig.spec.json'],
ignoreConfigErrors: true,
}),
],
test: {
testTimeout: 120_000,
hookTimeout: 120_000,
fileParallelism: false,
include: ['src/**/*.integration-test.ts'],
globalSetup: ['src/__tests__/global-setup.ts'],
env: {
TWENTY_API_URL,
TWENTY_API_KEY,
},
},
});
```
Șablonul generat include `src/__tests__/run-twenty.ts`, un utilitar auxiliar pentru subprocese care apelează CLI-ul global și analizează rezultatul său JSON. Setează `TWENTY_CLI` la o cale absolută către un executabil pentru a folosi o compilare locală a CLI-ului. Moștenește `TWENTY_API_URL` și `TWENTY_API_KEY`; nu este necesar niciun fișier de configurare în directorul home.
Folosește acest utilitar pentru configurare și curățare:
```ts src/__tests__/global-setup.ts
import { runTwenty } from './run-twenty';
export async function setup() {
const result = await runTwenty(['app', 'apply', '--create']);
if (!result.ok) throw new Error(result.error.message);
}
export async function teardown() {
const result = await runTwenty(['app', 'uninstall', '--yes']);
if (!result.ok) throw new Error(result.error.message);
}
```
Rulează testele de integrare într-un spațiu de lucru temporar: configurarea instalează aplicația, iar curățarea o dezinstalează. Pentru acoperirea instalării din registru, rulează `app publish --private`, urmat de `app install`, în loc de `app apply --create`.
## Scrierea unui test de integrare
Folosește `twenty-client-sdk` pentru a inspecta datele și metadatele după finalizarea configurării CLI-ului:
```ts
import { MetadataApiClient } from 'twenty-client-sdk/metadata';
import { expect, it } from 'vitest';
import { APPLICATION_UNIVERSAL_IDENTIFIER } from 'src/constants/universal-identifiers';
it('installs the app', async () => {
const result = await new MetadataApiClient().query({
findOneApplication: {
__args: { universalIdentifier: APPLICATION_UNIVERSAL_IDENTIFIER },
id: true,
},
});
expect(result.findOneApplication.id).toBeTruthy();
});
```
Pentru un manifest, citește `data.manifest` din `twenty app build --json`. Pentru testele funcțiilor implementate, folosește mutația `executeOneLogicFunction` a clientului de metadate cu un token de utilizator. Identifică funcția în cadrul ID-ului aplicației instalate înainte de a o invoca.
## Rularea testelor
Asigurați-vă că serverul Twenty local rulează, apoi:
```bash filename="Terminal"
yarn test
```
Sau în modul watch în timpul dezvoltării:
```bash filename="Terminal"
yarn test:watch
```
## Verificarea tipurilor
Puteți rula și verificarea tipurilor pe aplicație fără a rula testele:
```bash filename="Terminal"
twenty app typecheck
```
Aceasta verifică fișierul `tsconfig.json` al aplicației dvs. cu compilatorul TypeScript instalat, fără a genera fișiere, și raportează orice erori de tip. Aplicațiile create cu scaffolderul includ, de asemenea, un script `yarn typecheck` care acoperă și fișierele de test (`tsconfig.spec.json`).
## CI cu GitHub Actions
Scaffolderul generează un workflow gata de utilizare la `.github/workflows/ci.yml`. La fiecare push pe `main` și la fiecare pull request, acesta pornește un server Twenty efemer în runner (prin acțiunea `twentyhq/twenty/.github/actions/spawn-twenty-app-dev-test`), apoi rulează `yarn lint`, `yarn typecheck`, `yarn test:unit` și `yarn test` cu `TWENTY_API_URL` / `TWENTY_API_KEY` îndreptate către acel server. Nu sunt necesare secrete și poți fixa versiunea serverului prin variabila de mediu `TWENTY_VERSION` din partea de sus a workflow-ului.
Vezi [Publicare → CI/CD automatizat](/ro/developers/extend/apps/operations/publishing#automated-cicd-scaffolded-workflows) pentru un ghid complet al celor trei workflow-uri create cu scaffolderul (`ci.yml`, pipeline-ul de deploy `cd.yml` și `publish.yml` pentru publicare pe npm).
<PageBanner illustration="card-page-testing" />