JIRA integreren met Cucumber en Serenity/JS voor verbeterd testbeheer

Testautomatisering is cruciaal om de kwaliteit en betrouwbaarheid van applicaties te waarborgen. De combinatie van Serenity/JS, Cucumber en Playwright biedt een krachtig testraamwerk waarmee ontwikkelaars en testers heldere, expressieve tests in BDD-stijl kunnen schrijven en daarbij gebruik kunnen maken van de robuuste browserautomatiseringsmogelijkheden van Playwright. Wanneer geïntegreerd met JIRA, kunt u problemen efficiënt beheren en volgen, zodat eventuele bugs die tijdens het testen zijn ontdekt, worden geregistreerd en direct kunnen worden uitgevoerd.

In dit bericht geven we een eenvoudig voorbeeld van de integratie van JIRA met Cucumber, Serenity/JS en Playwright voor effectief testcasemanagement.

Vereisten

Om mee te kunnen doen, heb je het volgende nodig:

Node.js geïnstalleerd op uw computer
Cucumber, Serenity/JS en Playwright zijn opgenomen in uw project
Een JIRA-account en API-toegangstoken voor programmatische interactie met JIRA
Een JIRA-project om je problemen te beheren

Stap 1: Serenity/JS, Cucumber en Playwriter instellen

Als je dat nog niet hebt gedaan, kun je Cucumber, Serenity/JS en Playwright als afhankelijkheden installeren:

npm install --save @serenity-js/core @serenity-js/assertions @serenity-js/web @cucumber/cucumber @playwright/test

Om mee te kunnen doen, heb je het volgende nodig:

Node.js geïnstalleerd op uw computer
Cucumber, Serenity/JS en Playwright zijn opgenomen in uw project
Een JIRA-account en API-toegangstoken voor programmatische interactie met JIRA
Een JIRA-project om je problemen te beheren

Stap 1: Serenity/JS, Cucumber en Playwriter instellen

Als je dat nog niet hebt gedaan, kun je Cucumber, Serenity/JS en Playwright als afhankelijkheden installeren:

npm install --save @serenity-js/core @serenity-js/assertions @serenity-js/web @cucumber/cucumber @playwright/test

als je de installatie wilt overslaan, heb ik ook een voorbeeld van een github-omgeving die je kunt klonen, specifiek voor deze jira-integratieoefening. Deze github is een kloon van de originele github die door het senenity-team zelf is geleverd. [Cucumber JIRA Integration GitHub Repository] (https://github.com/learn-automated-testing/cucumberjiraintegration).

Voor meer informatie en de volledige codebase kun je de [Cucumber playwright serenity-js GitHub Repository] bekijken (https://github.com/serenity-js/serenity-js-cucumber-playwright-template).

Met deze configuratie kun je beginnen met het maken van je teststappen in Cucumber met Serenity/JS en Playwright voor soepele, krachtige beweringen en browserinteracties.

Stap 2: Definieer een komkommerstap met een JIRA-probleemrapport

Laten we eens kijken naar een voorbeeld waarbij we checkboxen testen op een webpagina en een JIRA-probleem willen registreren als een van de tests mislukt. Hier is een overzicht van hoe dit kan worden bereikt.

Stap 1: Definieer locators voor uw elementen

Je moet specifieke elementen op de pagina selecteren om te testen. In dit voorbeeld vinden we twee selectievakjes met Playwright:

import { PageElement, By } from '@serenity-js/web';

const FirstCheckbox = PageElement.located(By.css('[for="checkbox1"]')).describedAs('first checkbox');
const SmileyIconForFirst = PageElement.located(By.css('label[for="checkbox1"] .icon')).describedAs('smiley icon for first checkbox');

Stap 2: Schrijf teststappen om met deze elementen te interageren

Met beweringen kun je gedrag valideren. Hieronder proberen we het selectievakje aan te vinken en te controleren of het verwachte pictogram wordt weergegeven. Als de test mislukt, loggen we het probleem in JIRA.

Hier is een voorbeeld van een stappendefinitiebestand jira.steps.ts:

import { Given, When, Then } from '@cucumber/cucumber';
import { Actor } from '@serenity-js/core';
import { Navigate, PageElement, Click, isSelected, isVisible, Text } from '@serenity-js/web';
import { Ensure, equals } from '@serenity-js/assertions';
import { By } from '@serenity-js/web';
import { createJiraIssue } from '../../test/interactions/ReportToJira';
import { Browser, chromium } from '@playwright/test';

const FirstCheckbox = PageElement.located(By.css('[for="checkbox1"]')).describedAs('first checkbox');
const SecondCheckbox = PageElement.located(By.css('[for="checkbox2"]')).describedAs('second checkbox');
const SmileyIconForFirst = PageElement.located(By.css('label[for="checkbox1"] .icon')).describedAs('smiley icon for first checkbox');
const SmileyIconForSecond = PageElement.located(By.css('label[for="checkbox2"] .icon')).describedAs('smiley icon for second checkbox');

// Step to navigate to the Checkboxes page
Given('{actor} navigates to the Checkboxes page', async (actor: Actor) =>
    actor.attemptsTo(
        Navigate.to('https://practiceautomatedtesting.com/webelements/Checkboxes')
    )
);

// Step to check the first checkbox, ensuring visibility with Ensure
When('{pronoun} checks the first checkbox', async (actor: Actor) =>
    actor.attemptsTo(
        Ensure.that(FirstCheckbox, isVisible()),  // Ensure the checkbox is visible
        Click.on(FirstCheckbox)                   // Click the checkbox once visible
    )
);

// Step to verify that the first checkbox is checked and displays a smiley face
Then('{pronoun} should see that the first checkbox is checked with a smiley icon', async (actor: Actor) => {
    const featureFileName = 'Checkbox.feature';  // Feature file name for reference
    const gwtSteps = \`
      Given the user navigates to the Checkboxes page
      When the user checks the first checkbox
      Then the user should see that the first checkbox is checked with a smiley icon
    \`;
    
    try {
        await actor.attemptsTo(
            Ensure.that(FirstCheckbox, isSelected()),               // Ensure the first checkbox is selected
            Ensure.that(Text.of(SmileyIconForFirst), equals('😊'))  // Ensure the smiley icon shows a happy face
        );
    } catch (error) {
        console.error('Test failed:', error.message);
        await createJiraIssue(error.message, featureFileName, gwtSteps);  // Pass the error message, feature file name, and GWT steps
    }
});

Integratie met JIRA voor het volgen van problemen

Om automatisch een JIRA-issue te creëren wanneer een test mislukt, kunnen we een interactie toevoegen in ReportToJira.ts dat stuurt een PostRequest naar JIRA’s REST API. Hier is hoe:

import { actorCalled } from '@serenity-js/core';
import { CallAnApi, LastResponse, PostRequest, Send } from '@serenity-js/rest';
import { Ensure, equals } from '@serenity-js/assertions';

export async function createJiraIssue(errorDescription: string, featureFileName: string, gwtSteps: string) {
    const JIRA_BASE_URL = 'https://learnautomatedtesting.atlassian.net';
    const PROJECT_KEY = 'XSP';
    const ISSUE_TYPE = 'Bug';
    const JIRA_USERNAME = process.env.JIRA_USERNAME || 'your username'; //(is your email)
    const JIRA_API_TOKEN = process.env.JIRA_API_TOKEN || 'your api key';

    await actorCalled('JiraReporter')
        .whoCan(CallAnApi.at(JIRA_BASE_URL))
        .attemptsTo(
            Send.a(PostRequest.to('/rest/api/3/issue').with({
                fields: {
                    project: {
                        key: PROJECT_KEY,
                    },
                    summary: `Automated Test Failure in Feature: ${featureFileName} - Unable to Login`,
                    description: {
                        type: 'doc',
                        version: 1,
                        content: [
                            {
                                type: 'paragraph',
                                content: [
                                    {
                                        type: 'text',
                                        text: `The following feature file failed: Steps:

${gwtSteps}`
                                    }
                                ]
                            },
                            {
                                type: 'paragraph',
                                content: [
                                    {
                                        type: 'text',
                                        text: `The test failed with the following error:

${errorDescription}`
                                    }
                                ]
                            }
                        ]
                    },
                    issuetype: {
                        name: ISSUE_TYPE,
                    },
                },
            }).using({
                headers: {
                    'Authorization': `Basic ${Buffer.from(`${JIRA_USERNAME}:${JIRA_API_TOKEN}`).toString('base64')}`,
                    'Content-Type': 'application/json',
                }
            })),
            Ensure.that(LastResponse.status(), equals(201))
        );
}

Met deze configuratie kun je Playwright gebruiken voor browserinteracties, Serenity/JS voor testen in BDD-stijl en JIRA voor automatische probleemopsporing. Deze combinatie biedt een robuuste oplossing om de testdekking te behouden en bugs effectief aan te pakken.

Belangrijke opmerking over het creëren van defecten in het echte leven

In toepassingen in de praktijk creëert u doorgaans niet automatisch JIRA-defecten voor elke testfout in de automatisering. Deze aanpak kan leiden tot een overvloed aan problemen in JIRA. In plaats daarvan wordt aanbevolen om eerst de testresultaten te bekijken en vervolgens indien nodig selectief defecten voor specifieke fouten te creëren. Dit kan worden beheerd door een booleaanse vlag te implementeren om het ontstaan van defecten te controleren, zodat u opnieuw tests kunt uitvoeren waarvoor defecten moeten worden geregistreerd.

Voor meer informatie en de volledige codebase kun je de [Cucumber JIRA Integration GitHub Repository] bekijken (https://github.com/learn-automated-testing/cucumberjiraintegration).

learnautomatedtesting.com