Integrare API pentru testare de încărcare

Acest ghid explică cum să utilizați clientul API LoadFocus, atât prin interfața de linie de comandă (CLI), cât și prin utilizarea directă a bibliotecii JavaScript în aplicațiile dumneavoastră.

Cuprins

• Instalare
• Configurare
• Interfața de linie de comandă (CLI)
  • Executare test JMeter
  • Monitorizare stare test
  • Obținere rezultate
  • Lucrul cu praguri
  • Formate de ieșire
• Utilizare bibliotecă JavaScript
  • Configurare de bază
  • Client JMeter
  • Executarea testelor
  • Monitorizarea stării testului
  • Obținerea rezultatelor
  • Exemplu complet
• Utilizare avansată
  • Configurare HTTP personalizată
  • Gestionarea erorilor
  • Executare teste în paralel
• Depanare

Instalare

Instalare globală

npm install -g @loadfocus/loadfocus-api-client

Instalare în proiect local

npm install @loadfocus/loadfocus-api-client

Configurare

Înainte de a utiliza clientul API LoadFocus, trebuie să configurați credențialele API.

Configurare CLI

# Setare cheie API și ID echipă
loadfocus-api config set apikey YOUR_API_KEY
loadfocus-api config set teamid YOUR_TEAM_ID

# Verificare configurare
loadfocus-api config show

Configurare JavaScript

const { configManager } = require('@loadfocus/loadfocus-api-client');

// Setare configurare
configManager.set('apikey', 'YOUR_API_KEY');
configManager.set('teamid', 'YOUR_TEAM_ID');

// Verificare configurare
console.log(configManager.get('apikey')); // Ar trebui să afișeze cheia API
console.log(configManager.isConfigured()); // Ar trebui să afișeze true dacă toată configurarea necesară este setată

Interfața de linie de comandă (CLI)

Clientul API LoadFocus oferă un CLI complet pentru interacțiunea cu API-ul LoadFocus.

Executare test JMeter

Executarea unui test

# Executare test după nume
loadfocus-api jmeter execute --name "My JMeter Test"

# Executare test cu parametri specifici
loadfocus-api jmeter execute --name "My JMeter Test" --threads 50 --rampup 30 --duration 300

Rularea unui test și așteptarea finalizării

# Rulare test și așteptare finalizare
loadfocus-api jmeter run-test --name "My JMeter Test"

# Rulare test cu praguri
loadfocus-api jmeter run-test --name "My JMeter Test" --thresholds "avgresponse<=200,errors==0,p95<=250"

# Rulare test cu timeout și interval de verificare personalizate
loadfocus-api jmeter run-test --name "My JMeter Test" --waitTimeout 1800 --pollInterval 15

Monitorizare stare test

# Verificare stare test după nume și ID
loadfocus-api jmeter status --name "My JMeter Test" --id 12345

# Obținere listă rulări recente ale testelor
loadfocus-api jmeter runs --limit 10

Obținere rezultate

# Obținere rezultate pentru un test specific
loadfocus-api jmeter results --name "My JMeter Test" --id 12345

# Obținere rezultate cu metrici specifice
loadfocus-api jmeter results --name "My JMeter Test" --id 12345 --include samples,avgresponse,errors

Lucrul cu praguri

Comanda run-test suportă evaluarea pragurilor pentru a determina automat dacă un test trece sau eșuează pe baza metricilor de performanță.

# Rulare test cu praguri multiple
loadfocus-api jmeter run-test --name "My JMeter Test" --thresholds "avgresponse<=200,errors==0,p95<=250,hitspersec>=10"

Operatori de prag suportați:

• <= - Mai mic sau egal cu
• < - Mai mic decât
• >= - Mai mare sau egal cu
• > - Mai mare decât
• == - Egal cu
• != - Diferit de

Formate de ieșire

# Obținere rezultate în format JSON
loadfocus-api jmeter run-test --name "My JMeter Test" --format json > results.json

# Ieșire formatată implicit
loadfocus-api jmeter run-test --name "My JMeter Test"

Utilizare bibliotecă JavaScript

Clientul API LoadFocus poate fi utilizat și direct ca bibliotecă JavaScript în aplicațiile dumneavoastră.

Configurare de bază

// Import clientul API LoadFocus
const loadfocus = require('@loadfocus/loadfocus-api-client');

// Accesare componente specifice
const { JMeterClient, configManager } = loadfocus;

Client JMeter

// Creare client JMeter
const jmeterClient = new loadfocus.JMeterClient();

// Sau cu configurare explicită
const jmeterClient = new loadfocus.JMeterClient({
  apikey: 'YOUR_API_KEY',
  teamid: 'YOUR_TEAM_ID'
});

Executarea testelor

async function executeTest() {
  try {
    const result = await jmeterClient.execute({
      testrunname: 'My JMeter Test',
      threads: 50,
      rampup: 30,
      duration: 300
    });

    console.log('Test execution started:', result);
    return result.testrunid; // Returnează ID-ul testului pentru utilizare ulterioară
  } catch (error) {
    console.error('Error executing test:', error);
  }
}

Monitorizarea stării testului

async function checkTestStatus(testName, testId) {
  try {
    const status = await jmeterClient.getStatus({
      testrunname: testName,
      testrunid: testId
    });

    console.log('Test status:', status);
    return status.state; // Returnează starea curentă
  } catch (error) {
    console.error('Error checking test status:', error);
  }
}

Obținerea rezultatelor

async function getTestResults(testName, testId) {
  try {
    // Obținere etichete disponibile pentru test
    const labels = await jmeterClient.getLabels({
      testrunname: testName,
      testrunid: testId
    });

    console.log('Test labels:', labels);

    // Obținere rezultate pentru fiecare etichetă
    const allResults = [];
    for (const label of labels) {
      const labelResults = await jmeterClient.getResults({
        testrunname: testName,
        testrunid: testId,
        filter: label
      });

      allResults.push({
        label,
        results: labelResults
      });
    }

    console.log('Test results:', allResults);
    return allResults;
  } catch (error) {
    console.error('Error retrieving test results:', error);
  }
}

Exemplu complet

Iată un exemplu complet care execută un test, așteaptă finalizarea și obține rezultatele:

const { JMeterClient, configManager } = require('@loadfocus/loadfocus-api-client');

// Configurare
configManager.set('apikey', 'YOUR_API_KEY');
configManager.set('teamid', 'YOUR_TEAM_ID');

// Creare client
const jmeterClient = new JMeterClient();

async function runCompleteTest() {
  try {
    // Executare test
    console.log('Executing test...');
    const executeResult = await jmeterClient.execute({
      testrunname: 'My JMeter Test'
    });

    const testId = executeResult.testrunid;
    console.log(`Test execution started with ID: ${testId}`);

    // Așteptare finalizare
    console.log('Waiting for test to complete...');
    let completed = false;
    while (!completed) {
      const status = await jmeterClient.getStatus({
        testrunname: 'My JMeter Test',
        testrunid: testId
      });

      console.log(`Current state: ${status.state}`);

      if (status.state === 'finished') {
        completed = true;
      } else if (status.state === 'failed' || status.state === 'error') {
        throw new Error(`Test failed with state: ${status.state}`);
      } else {
        // Așteptare înainte de verificare din nou
        await new Promise(resolve => setTimeout(resolve, 10000));
      }
    }

    // Obținere rezultate
    console.log('Getting test results...');
    const labels = await jmeterClient.getLabels({
      testrunname: 'My JMeter Test',
      testrunid: testId
    });

    const allResults = [];
    for (const label of labels) {
      const labelResults = await jmeterClient.getResults({
        testrunname: 'My JMeter Test',
        testrunid: testId,
        filter: label
      });

      allResults.push({
        label,
        results: labelResults
      });
    }

    console.log('Test results:', JSON.stringify(allResults, null, 2));
    return allResults;
  } catch (error) {
    console.error('Error running test:', error);
  }
}

// Rulare test
runCompleteTest();

Utilizare avansată

Configurare HTTP personalizată

Puteți personaliza clientul HTTP utilizat de clientul API LoadFocus:

const { JMeterClient } = require('@loadfocus/loadfocus-api-client');

// Creare client cu opțiuni HTTP personalizate
const jmeterClient = new JMeterClient({
  apikey: 'YOUR_API_KEY',
  teamid: 'YOUR_TEAM_ID',
  httpOptions: {
    timeout: 30000, // 30 secunde
    retries: 3,
    headers: {
      'User-Agent': 'My Custom Application'
    }
  }
});

Gestionarea erorilor

Clientul API LoadFocus oferă informații detaliate despre erori:

try {
  const result = await jmeterClient.execute({
    testrunname: 'My JMeter Test'
  });
} catch (error) {
  if (error.response) {
    // Cererea a fost făcută și serverul a răspuns cu un cod de stare
    // în afara intervalului 2xx
    console.error('API Error:', error.response.status, error.response.data);
  } else if (error.request) {
    // Cererea a fost făcută dar nu s-a primit niciun răspuns
    console.error('Network Error:', error.request);
  } else {
    // Ceva s-a întâmplat la configurarea cererii care a declanșat o eroare
    console.error('Request Error:', error.message);
  }
}

Depanare

Probleme frecvente

1. Erori de autentificare:

   • Asigurați-vă că cheia API și ID-ul echipei sunt configurate corect
   • Verificați că cheia API are permisiunile necesare

2. Eșuări la executarea testelor:

   • Verificați că numele testului există în contul LoadFocus
   • Verificați dacă ați atins limita de teste concurente a contului

3. Probleme de timeout:

   • Pentru teste de lungă durată, creșteți parametrul waitTimeout
   • Luați în considerare implementarea unui mecanism de verificare periodică în loc de așteptare sincronă

4. Probleme la obținerea rezultatelor:

   • Asigurați-vă că testul s-a finalizat înainte de a obține rezultatele
   • Verificați dacă ID-ul testului este corect

Depanare

Activați jurnalizarea de depanare pentru informații mai detaliate:

// În codul JavaScript
process.env.DEBUG = 'true';

// Sau când utilizați CLI
DEBUG=true loadfocus-api jmeter run-test --name "My JMeter Test"

Pentru ajutor suplimentar, consultați documentația API LoadFocus sau contactați suportul.