Skip to content

The open alternative to Salesforce, designed for AI.

8.1 KB
Raw Blame
---
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" />