Algolia

    API-integration för lasttestning

    Denna guide förklarar hur du använder LoadFocus API-klienten, både via kommandoradsgränssnittet (CLI) och genom att direkt använda JavaScript-biblioteket i dina applikationer.

    Innehållsförteckning

    Installation

    Global installation

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

    Lokal projektinstallation

    npm install @loadfocus/loadfocus-api-client

    Konfiguration

    Innan du använder LoadFocus API-klienten behöver du konfigurera dina API-uppgifter.

    CLI-konfiguration

    # Ange API-nyckel och team-ID
    loadfocus-api config set apikey YOUR_API_KEY
    loadfocus-api config set teamid YOUR_TEAM_ID
    

    # Verifiera konfiguration
    loadfocus-api config show

    JavaScript-konfiguration

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

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

    // Verifiera konfiguration
    console.log(configManager.get('apikey')); // Ska skriva ut din API-nyckel
    console.log(configManager.isConfigured()); // Ska skriva ut true om all nödvändig konfiguration är angiven

    Kommandoradsgränssnitt (CLI)

    LoadFocus API-klienten tillhandahåller ett omfattande CLI för att interagera med LoadFocus API.

    JMeter-testkörning

    Köra ett test

    # Kör ett test efter namn
    loadfocus-api jmeter execute --name "My JMeter Test"
    

    # Kör ett test med specifika parametrar
    loadfocus-api jmeter execute --name "My JMeter Test" --threads 50 --rampup 30 --duration 300

    Köra ett test och vänta på slutförande

    # Kör ett test och vänta på slutförande
    loadfocus-api jmeter run-test --name "My JMeter Test"
    

    # Kör ett test med tröskelvärden
    loadfocus-api jmeter run-test --name "My JMeter Test" --thresholds "avgresponse<=200,errors==0,p95<=250"
    

    # Kör ett test med anpassad timeout och pollningsintervall
    loadfocus-api jmeter run-test --name "My JMeter Test" --waitTimeout 1800 --pollInterval 15

    Övervakning av teststatus

    # Kontrollera status för ett test med namn och ID
    loadfocus-api jmeter status --name "My JMeter Test" --id 12345
    

    # Hämta en lista över senaste testkörningar
    loadfocus-api jmeter runs --limit 10

    Hämtning av resultat

    # Hämta resultat för ett specifikt test
    loadfocus-api jmeter results --name "My JMeter Test" --id 12345
    

    # Hämta resultat med specifika mätvärden
    loadfocus-api jmeter results --name "My JMeter Test" --id 12345 --include samples,avgresponse,errors

    Arbeta med tröskelvärden

    Kommandot run-test stöder utvärdering av tröskelvärden för att automatiskt avgöra om ett test godkänns eller underkänns baserat på prestandamätvärden.

    # Kör ett test med flera tröskelvärden
    loadfocus-api jmeter run-test --name "My JMeter Test" --thresholds "avgresponse<=200,errors==0,p95<=250,hitspersec>=10"

    Stödda tröskeloperatorer:

    • <= - Mindre än eller lika med
    • < - Mindre än
    • >= - Större än eller lika med
    • > - Större än
    • == - Lika med
    • != - Inte lika med

    Utdataformat

    # Hämta resultat i JSON-format
    loadfocus-api jmeter run-test --name "My JMeter Test" --format json > results.json
    

    # Standard formaterad utskrift
    loadfocus-api jmeter run-test --name "My JMeter Test"

    Användning av JavaScript-biblioteket

    LoadFocus API-klienten kan också användas direkt som ett JavaScript-bibliotek i dina applikationer.

    Grundläggande konfiguration

    // Importera LoadFocus API-klienten
    const loadfocus = require('@loadfocus/loadfocus-api-client');
    

    // Åtkomst till specifika komponenter
    const { JMeterClient, configManager } = loadfocus;

    JMeter-klient

    // Skapa en JMeter-klient
    const jmeterClient = new loadfocus.JMeterClient();
    

    // Eller med explicit konfiguration
    const jmeterClient = new loadfocus.JMeterClient({
      apikey: 'YOUR_API_KEY',
      teamid: 'YOUR_TEAM_ID'
    });

    Köra tester

    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; // Returnera test-ID för senare användning
      } catch (error) {
        console.error('Error executing test:', error);
      }
    }

    Övervaka teststatus

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

        console.log('Test status:', status);
        return status.state; // Returnera aktuellt tillstånd
      } catch (error) {
        console.error('Error checking test status:', error);
      }
    }

    Hämta resultat

    async function getTestResults(testName, testId) {
      try {
        // Hämta tillgängliga etiketter för testet
        const labels = await jmeterClient.getLabels({
          testrunname: testName,
          testrunid: testId
        });
    

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

        // Hämta resultat för varje etikett
        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);
      }
    }

    Komplett exempel

    Här är ett komplett exempel som kör ett test, väntar på slutförande och hämtar resultat:

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

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

    // Skapa klient
    const jmeterClient = new JMeterClient();
    

    async function runCompleteTest() {
      try {
        // Kör testet
        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}`);
    

        // Vänta på slutförande
        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 {
            // Vänta innan nästa kontroll
            await new Promise(resolve => setTimeout(resolve, 10000));
          }
        }
    

        // Hämta resultat
        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);
      }
    }
    

    // Kör testet
    runCompleteTest();

    Avancerad användning

    Anpassad HTTP-konfiguration

    Du kan anpassa HTTP-klienten som används av LoadFocus API-klienten:

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

    // Skapa klient med anpassade HTTP-alternativ
    const jmeterClient = new JMeterClient({
      apikey: 'YOUR_API_KEY',
      teamid: 'YOUR_TEAM_ID',
      httpOptions: {
        timeout: 30000, // 30 sekunder
        retries: 3,
        headers: {
          'User-Agent': 'My Custom Application'
        }
      }
    });

    Felhantering

    LoadFocus API-klienten tillhandahåller detaljerad felinformation:

    try {
      const result = await jmeterClient.execute({
        testrunname: 'My JMeter Test'
      });
    } catch (error) {
      if (error.response) {
        // Förfrågan gjordes och servern svarade med en statuskod
        // som faller utanför intervallet 2xx
        console.error('API Error:', error.response.status, error.response.data);
      } else if (error.request) {
        // Förfrågan gjordes men inget svar mottogs
        console.error('Network Error:', error.request);
      } else {
        // Något hände vid konfigureringen av förfrågan som utlöste ett fel
        console.error('Request Error:', error.message);
      }
    }

    Felsökning

    Vanliga problem

    1. Autentiseringsfel:

      • Se till att din API-nyckel och ditt team-ID är korrekt konfigurerade
      • Kontrollera att din API-nyckel har nödvändiga behörigheter

    2. Misslyckade testkörningar:

      • Verifiera att testnamnet finns i ditt LoadFocus-konto
      • Kontrollera om du har nått ditt kontos gräns för samtidiga tester

    3. Timeout-problem:

      • För långvariga tester, öka parametern waitTimeout
      • Överväg att implementera en pollningsmekanism istället för att vänta synkront

    4. Problem med att hämta resultat:

      • Se till att testet har slutförts innan du hämtar resultat
      • Kontrollera att test-ID:t är korrekt

    Felsökning

    Aktivera felsökningsloggning för mer detaljerad information:

    // I din JavaScript-kod
    process.env.DEBUG = 'true';
    

    // Eller vid användning av CLI
    DEBUG=true loadfocus-api jmeter run-test --name "My JMeter Test"

    För ytterligare hjälp, se LoadFocus API-dokumentationen eller kontakta supporten.

    Föregående
    Hur man kör ett nytt Apache JMeter-lasttest
    Nästa
    Azure DevOps