Testování

SDK poskytuje programová rozhraní, která vám umožní z testovacího kódu aplikaci sestavit, nasadit, nainstalovat a odinstalovat. V kombinaci s Vitest a typovanými klienty API můžete psát integrační testy, které ověří, že vaše aplikace funguje end-to-end proti reálnému serveru Twenty.

Používání balíčků npm

Ve své aplikaci můžete nainstalovat a používat libovolný balíček npm. Logické funkce i frontendové komponenty se bundlují pomocí esbuild, který vloží všechny závislosti přímo do výstupu — za běhu nejsou potřeba žádné node_modules.

Instalace balíčku

yarn add axios

Poté jej importujte ve svém kódu:

src/logic-functions/fetch-data.ts

import { defineLogicFunction } from 'twenty-sdk/define';
import axios from 'axios';

const handler = async (): Promise<any> => {
  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,
});

Stejně to funguje i pro frontendové komponenty:

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,
});

Jak funguje bundlování

Krok sestavení používá esbuild k vytvoření jediného samostatného souboru pro každou logickou funkci a každou frontendovou komponentu. Všechny importované balíčky jsou vloženy přímo do bundlu. Logické funkce běží v prostředí Node.js. Vestavěné moduly Node (fs, path, crypto, http atd.) jsou k dispozici a není je třeba instalovat. Frontendové komponenty běží ve Web Workeru. Vestavěné moduly Node nejsou k dispozici — pouze prohlížečová API a balíčky npm, které fungují v prohlížečovém prostředí. V obou prostředích jsou jako předpřipravené moduly k dispozici twenty-client-sdk/core a twenty-client-sdk/metadata — nejsou součástí bundlu, ale server je za běhu načítá.

Nastavení

Vygenerovaná aplikace již obsahuje Vitest. Pokud to nastavujete ručně, nainstalujte závislosti:

yarn add -D vitest vite-tsconfig-paths

Vytvořte vitest.config.ts v kořeni vaší aplikace:

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,
    },
  },
});

Vytvořte globální soubor pro nastavení, který ověří, že je server dosažitelný, zapíše testovací konfiguraci pro SDK (~/.twenty/config.test.json) a před spuštěním testů provede synchronizaci aplikace:

src/__tests__/global-setup.ts

import * as fs from 'fs';
import * as os from 'os';
import * as path from 'path';

import { appDevOnce, appUninstall } from 'twenty-sdk/cli';

const APP_PATH = process.cwd();
const CONFIG_DIR = path.join(os.homedir(), '.twenty');

export async function setup() {
  const apiUrl = process.env.TWENTY_API_URL!;
  const apiKey = process.env.TWENTY_API_KEY!;

  // Verify the server is running
  const response = await fetch(`${apiUrl}/healthz`);
  if (!response.ok) {
    throw new Error(`Twenty server is not reachable at ${apiUrl}.`);
  }

  // Write the SDK's test config (the CLI reads config.test.json when NODE_ENV=test)
  fs.mkdirSync(CONFIG_DIR, { recursive: true });
  fs.writeFileSync(
    path.join(CONFIG_DIR, 'config.test.json'),
    JSON.stringify({
      remotes: { local: { apiUrl, apiKey } },
      defaultRemote: 'local',
    }, null, 2),
  );

  // Start from a clean slate, then sync the app
  await appUninstall({ appPath: APP_PATH }).catch(() => {});

  const result = await appDevOnce({ appPath: APP_PATH });
  if (!result.success) {
    throw new Error(`Dev sync failed: ${result.error?.message}`);
  }
}

export async function teardown() {
  await appUninstall({ appPath: APP_PATH });
}

Programová rozhraní SDK

Subcesta twenty-sdk/cli exportuje funkce, které můžete volat přímo z testovacího kódu:

Funkce	Popis
`appBuild`	Sestaví aplikaci a volitelně zabalí tarball
`appDeploy`	Nahraje tarball na server
`appDevOnce`	Jednorázově sestaví a synchronizuje aplikaci (stejně jako `yarn twenty apply`)
`appInstall`	Nainstaluje aplikaci do aktivního pracovního prostoru
`appUninstall`	Odinstaluje aplikaci z aktivního pracovního prostoru

Každá funkce vrací objekt výsledku se success: boolean a buď data, nebo error.

Psání integračního testu

Zde je kompletní příklad, který aplikaci sestaví, nasadí a nainstaluje a poté ověří, že se objeví v pracovním prostoru:

src/__tests__/app-install.integration-test.ts

import { APPLICATION_UNIVERSAL_IDENTIFIER } from 'src/application-config';
import { appBuild, appDeploy, appInstall, appUninstall } from 'twenty-sdk/cli';
import { MetadataApiClient } from 'twenty-client-sdk/metadata';
import { afterAll, beforeAll, describe, expect, it } from 'vitest';

const APP_PATH = process.cwd();

describe('App installation', () => {
  beforeAll(async () => {
    const buildResult = await appBuild({
      appPath: APP_PATH,
      tarball: true,
      onProgress: (message: string) => console.log(`[build] ${message}`),
    });

    if (!buildResult.success) {
      throw new Error(`Build failed: ${buildResult.error?.message}`);
    }

    const deployResult = await appDeploy({
      tarballPath: buildResult.data.tarballPath!,
      onProgress: (message: string) => console.log(`[deploy] ${message}`),
    });

    if (!deployResult.success) {
      throw new Error(`Deploy failed: ${deployResult.error?.message}`);
    }

    const installResult = await appInstall({ appPath: APP_PATH });

    if (!installResult.success) {
      throw new Error(`Install failed: ${installResult.error?.message}`);
    }
  });

  afterAll(async () => {
    await appUninstall({ appPath: APP_PATH });
  });

  it('should find the installed app in the workspace', async () => {
    const metadataClient = new MetadataApiClient();

    const result = await metadataClient.query({
      findManyApplications: {
        id: true,
        name: true,
        universalIdentifier: true,
      },
    });

    const installedApp = result.findManyApplications.find(
      (app: { universalIdentifier: string }) =>
        app.universalIdentifier === APPLICATION_UNIVERSAL_IDENTIFIER,
    );

    expect(installedApp).toBeDefined();
  });
});

Spuštění testů

Ujistěte se, že běží váš lokální server Twenty, a poté:

yarn test

Nebo v režimu watch během vývoje:

yarn test:watch

Kontrola typů

Kontrolu typů můžete spustit i na vaší aplikaci bez spuštění testů:

yarn twenty dev:typecheck

Spustí se tsc --noEmit proti souboru tsconfig.json vaší aplikace a nahlásí se případné chyby typů. Vygenerované aplikace také obsahují skript yarn typecheck, který pokrývá i testovací soubory (tsconfig.spec.json).

CI s GitHub Actions

Generátor kostry vytvoří připravený k použití workflow v .github/workflows/ci.yml. Při každém pushi do main a při každém pull requestu spustí efemérní server Twenty v runneru (pomocí akce twentyhq/twenty/.github/actions/spawn-twenty-app-dev-test), poté spustí yarn lint, yarn typecheck, yarn test:unit a yarn test s TWENTY_API_URL / TWENTY_API_KEY směřujícími na tento server. Nejsou vyžadovány žádné tajné údaje a verzi serveru můžete připnout pomocí proměnné prostředí TWENTY_VERSION na začátku workflow. Úplný postup pro tři workflow generované kostrou (ci.yml, nasazovací pipeline cd.yml a publish.yml pro publikování na npm) najdete v části Publishing → Automated CI/CD.

Přehled

Aplikace

API

Vlastní hosting

Přispět

Používání balíčků npm

Instalace balíčku

Jak funguje bundlování

Nastavení

Programová rozhraní SDK

Psání integračního testu

Spuštění testů

Kontrola typů

CI s GitHub Actions

​Používání balíčků npm

​Instalace balíčku

​Jak funguje bundlování

​Nastavení

​Programová rozhraní SDK

​Psání integračního testu

​Spuštění testů

​Kontrola typů

​CI s GitHub Actions

Používání balíčků npm

Instalace balíčku

Jak funguje bundlování

Nastavení

Programová rozhraní SDK

Psání integračního testu

Spuštění testů

Kontrola typů

CI s GitHub Actions