Ebben az oktatóanyagban a kimerítő készleteket fogjuk megvitatni Critical TestNg interjú kérdések és válaszok és a nehézségi szinttől függően elosztva, ahol jobban fel tudhatod magad gyorsan felszerelni a TestNg-n
Ezek a Testng interjúkérdések a következő modulokban vagy készletekben vannak elosztva:
TestNg interjúkérdések – előre
- Hogyan zárhat ki egy csoportot a tesztvégrehajtási ciklusból?
- Hhogyan lehet elérni a TestNG itestlistener megvalósítását?
- Hogyan valósítsuk meg az iAnnotationtransformer tesztelését?
- Hogyan implementálható a testng iinvokedmethodlistener?
- Az adatszolgáltatók implementálása a TestNG-ben
- Ha nem állítjuk be a tesztmódszer prioritását, milyen sorrendben történjenek a tesztek a TestNG-ben
- Milyen típusú jelentések készülnek alapértelmezés szerint a TestNG-ben?
- Említse meg a különbséget a TestNG tesztkészlet és a TestNG teszt között?
- Mire használható a threadPoolSize attribútum a @Test annotációval
- Mit csinálnak az AlwaysRun attribútumok?
- Milyen különböző hallgatók állnak rendelkezésre?
- Mi a TestNG Priority alapértelmezett értéke?
- Hogyan lehet újra futtatni a TestNg sikertelen teszteket az automatikus újrapróbálkozási mechanizmus segítségével?
- Hogyan lehet párhuzamosan futtatni a teszt szkripteket?
- Hogyan integrálható a TestNg a GRADLE build Tool-ba?
- A Testng Default figyelő futtatása a Gradle-lel, hogy jelentést készítsen a TestNg könyvtár használatával
- Hogyan lehet futtatni a Testng Runner xml fájlt parancssor segítségével?
- Hogyan integrálható a TestNg XML a Maven-nel?
- Hogyan adhatja meg a TestNg Test paramétert a TestNg és a Maven használatával?
TestNg interjúkérdések – Közbülső
- Mit jelent az invocationCount a TestNG-ben?
- Mik a hallgatók a TestNG-ben?
- Említse meg a @Factory és a @Dataprovider megjegyzések közötti különbségeket a TestNg-ben?
- Hogyan használjuk a TestNG Reporter Class-t a napló generálásához?
- Hogyan lehet kivételkezelést végrehajtani a TestNG-ben?
- Hogyan lehet elérni a függőségi injekciót a TestNg XML-en keresztül?
- Melyek a TestNG különféle állítási megközelítései?
- Említsen meg néhány gyakran használt állítást a TestNG-nél
- Mit értesz a TestNG állításai alatt?
- Különbség a kemény és lágy állítás között a TestNg-ben
- Hogyan írjunk lágy állítást a TestNg-ben
- Hogyan használjunk reguláris kifejezést a TestNG csoportokban?
TestNg interjúkérdések – alap
- Mi az a TestNG?
- Mik a TestNg előnyei?
- Hogyan lehet elindítani és végrehajtani a TestNg tesztszkriptet?
- Adja meg a rendelkezésre álló Testng annotációkat?
- Megemlíti a TestNg annotációk végrehajtási sorrendjét?
- Hogyan lehet letiltani a tesztvégrehajtást egy tesztszkriptnél?
- Hogyan adhat meg figyelőket a TestNG xml-ben?
- Mi az időtúllépési teszt a TestNg-ben?
- Hogyan lehet elérni a várható kivételtesztet a TestNG segítségével?
- Mi a különbség a @BeforeTest és a #@BeforeMethod annotáció között?
- Milyen előnyökkel jár a testng.xml fájl használata?
- Hány féle függőséget érhet el a TestNG használatával?
Testng Interjú kérdések és válaszok || 1. készlet
Hogyan zárhat ki egy csoportot a tesztvégrehajtási ciklusból?
A kizárás címkével kizárhatja a tesztesetek egy csoportját a végrehajtásból az alábbi módon a Testng xml fájlban
Milyen típusú jelentések készülnek alapértelmezés szerint a TestNG-ben?
A TestNG 4 féle jelentést készít a végrehajtás után, amelyek a következők:
- TestNG HTML jelentés
- TestNG E-mailben elküldhető jelentés
- TestNG Report XML
- TestNg Sikertelen XML-jelentés
Említse meg a különbséget a TestNG tesztkészlet és a TestNG teszt között?
A TestNG tesztcsomag olyan tesztosztályok és tesztmódszerek gyűjteménye, amelyek egyidejűleg és párhuzamosan is futtathatók a TestNG XML fájlból.
Másrészt a TestNG tesztmódszer egyetlen teszteset fájl vagy tesztmódszer.
Mire használható a threadPoolSize attribútum a @Test annotációval
A threadPoolSize attribútum segítségével meghatározhatunk egy szálkészletet a megadott mérettel a tesztmetódus számával, amelyet több elérhető szálon keresztül kell végrehajtani.
Az attribútumot a rendszer figyelmen kívül hagyja, ha az invocationCount nem kerül említésre.
@Teszt(szálPoolSize = 3)
public void testCaseOne(){
System.out.println("testCaseOne folyamatban");
}
A fenti tesztmódszerben a testCaseOne a három különböző szálból kerül meghívásra.
Mit csinálnak az AlwaysRun attribútumok?
Ez az alwaysRun annotation attribútum akkor használatos, amikor a tesztmódszert végre akarja hajtani, függetlenül attól, hogy a tesztmódszer milyen függő paraméterektől függ, és sikertelen. Ha igazra állítja, akkor az attribútumot igazra kell állítani.
Milyen különböző hallgatók állnak rendelkezésre?
- ITestListener
- IReporter
- ISuiteListener
- IAnnotationTransformer
- IAnnotationTransformer2
- Megfogható
- IInvokedMethodListener
- IMethodInterceptor
Mi a TestNG Priority alapértelmezett értéke?
A TestNG prioritás alapértelmezett értéke nulla.
Hogyan lehet újra futtatni a TestNg sikertelen teszteket az automatikus újrapróbálkozási mechanizmus segítségével?
A TestNg egy interfészt biztosít, amelyet asnak neveznek IRetryAnalyzer figyelő, amely a felületet megvalósíthatja, és automatikusan újraindíthatja a sikertelen teszt szkripteket, ha megemlíti az osztályt a testNg.XML fájlban , Íme az alábbi kód ugyanezen megvalósításhoz:
A fenti területen beállíthatja az újrapróbálkozások számát, a maximális számokat, és azt is meg lehet említeni, hogy mely kivételeknél szeretné újra futtatni a teszt szkripteket.
public class Retry implementálja az IRetryAnalyzert { int retryCounter = 0; // A sikertelen végrehajtások maximális száma int autoRetryLimit = 2; @A nyilvános logikai érték felülbírálása újrapróbálkozás(ITestResult iTestResult) { if (retryCounter < autoRetryLimit) { retryCounter++; return true; } return false; } }
Második megközelítés: Hogyan futtassuk újra a TestNg sikertelen teszteket az automatikus újrapróbálkozási mechanizmus segítségével
Az alábbi megközelítésben 2 osztályt építhetsz, azaz egyet Próbálja újra az osztályt ahol megtarthatja az iterációk számának szabályozási logikáját teszthibák esetén, amely megvalósítja a Testng felületet IRetryAnalyzer.
Egy másik osztály alapvetően az IAnnotationTransformer másik interfész figyelőt valósítja meg, és implementálja a metódust át amely belső kölcsönhatásba lép az előző osztállyal (pl Próbálja újra az osztályt)
public class Retry implementálja az IRetryAnalyzert { int retryCounter = 0; // A sikertelen végrehajtások maximális száma int autoRetryLimit = 2; @A nyilvános logikai érték felülbírálása újrapróbálkozás(ITestResult iTestResult) { if (retryCounter < autoRetryLimit) { retryCounter++; return true; } return false; } }
és végül hozzáadjuk a CognitiveRetry osztály a testng.xml fájl figyelőjében.
<listeners>
<listener class-name= "com.lambdageeks.cognitiveRetryUtils.CognitiveRetry"/>
</listeners>
Hogyan érhető el a TestNG itestlistener implementációja?
Az ITestListener egy olyan felület a TestNg-ben, amely több metódussal rendelkezik (az interfész óta nincs implementálva), amelyeket egy osztály implementálhat. Mindegyik metódus meghatározott funkciókat vagy forgatókönyveket képvisel, ezért az igényektől függően ezeket a módszereket megvalósíthatja.
Példának okáért onTestFailure egy olyan módszer , amelyet megvalósíthat , ha bármilyen műveletet szeretne végrehajtani , miközben bármelyik tesztmódszer meghiúsul , mondjuk a képernyőképet szeretné rögzíteni , miközben bármilyen tesztmódszer hibája esetén beírhatja a takescreenshot metódust a onTestFailure , és mivel az ITestListener egy interfész, így a testNg folyamatosan figyeli az eseményeket (teszthiba), és ha teszthiba történik, a képernyőkép rögzítésre kerül.
Íme a képernyőkép rögzítésének megvalósítása, amikor a tesztszkript hibába ütközik:
import org.apache.commons.io.FileUtils; import org.openqa.selenium.OutputType; import org.openqa.selenium.TakesScreenshot; import org.openqa.selenium.WebDriver; import org.testng.ITestContext; import org.testng.ITestListener; import org.testng.ITestResult; import java.io.File; import java.io.IOException; import java.util.logging.Logger; public class CustomListerners implementálja az ITestListener { WebDriver driver=null; String filePath = "D:\\LambdaGeeks\\SCREENSHOTS"; @A public void felülbírálása onTestFailure(ITestResult result) { String testMethodName=String.valueOf(result.getName()).trim(); ITestContext testContext = result.getTestContext(); WebDriver illesztőprogram = (WebDriver)testContext.getAttribute("illesztőprogram"); captureTheScreenShot(tesztmódszernév, illesztőprogram); } public void captureTheScreenShot(String methodName, WebDriver driver) { File scrFile = ((TakesScreenshot)driver).getScreenshotAs(OutputType.FILE); /* Minden képernyőkép a tesztnévvel együtt mentésre kerül a jobb korreláció érdekében */ try { FileUtils.copyFile(scrFile, new File(filePath+methodName+".jpg")); } catch (IOException e) { e.printStackTrace(); } } public void onFinish(ITestContext kontextus) {} public void onTestStart(ITestResult result) { } public void onTestSuccess(ITestResult result) { } public void onTestSkipped(ITestResult result) { } public void onTestFailedButResultSuccest} (ITestContext kontextus) { } }
Ezenkívül hozzá kell adnia ezt az osztályt a testng.xml fájl figyelő címkéjéhez, ahogy az előző kérdésben tettük.
Hogyan valósítsuk meg az iAnnotationtransformer tesztelését?
A TestNg egy IAnnotationTransformer nevű interfészt biztosít, amely egy „transzformációnak” nevezett metódust biztosít, amelyet megvalósíthat, és amelyet a TestNG futás közben indítana el. Ez a megvalósítás a tesztosztály és a vizsgálati módszerek tesztannotációs viselkedésének módosítására szolgál.
Az alábbi szegmensben megnézzük, hogyan tehetjük ezt meg
public class TestClassAnnotations { @Test(alwaysRun = true,dependsOnMethods = "testMethodB") public void testMethodA() { System.out.println("--- A futásidejű viselkedés testreszabása az ITestAnnotation segítségével ---"); } @Test public void testMethodB() { System.out.println("--- Második tesztmódszerek ---"); Assert.fail(); } }
Alapértelmezés szerint, ha a fenti kódot futtatjuk, akkor csak egy metódus kerül végrehajtásra, ez a testMethodA, és egy másik testMethodB metódus meghiúsul, mert szándékosan kudarcot vallatunk az Assert.fail() metódus használatával.
De ha megváltoztatjuk a Alwaysrun=true annotáció hamisra a segítségével IAnnotationTransformer akkor ez a metódus nem kerül végrehajtásra , alább látható a kódrészlet a megvalósítás módjáról IAnnotationTransformer és használja a testing.xml fájlban a TestNG annotáció viselkedésének megváltoztatásához
A CustomAnnotationTransformers megvalósítása itt található:
public class CustomAnnotationTransformers implementálja az IAnnotationTransformer { public logikai értéket isTestRunning(ITestAnnotation iTestAnnotation) { if (iTestAnnotation.getAlwaysRun()) { return true; } return false; } public void transzformáció(ITestAnnotation annotations, Class testClasses, Constructor testConstructors, Method testMethods) { if (isTestRunning(annotations)) { annotations.setEnabled(false); } } }
Itt van a figyelő, amelyet hozzá kell adnunk a testing.xml fájlhoz
<listeners>
<listener class-name= "com.lambdageeks.CustomAnnotationTransformers"/>
</listeners>
Hogyan implementálható a testng iinvokedmethodlistener?
Ha olyan szolgáltatást szeretne megvalósítani, amelyben egy bizonyos módszer végrehajtásra kerül a TestNg minden egyes tesztmódszere előtt és után, akkor ezt a funkciót a testng implementálhatja. IInvokedMethodListener hallgató.
Íme a kódrészlet a funkciók megvalósításához:
csomag com.lambdageeks; import org.testng.IInvokedMethod; import org.testng.IInvokedMethodListener; import org.testng.ITestResult; public class CustomAnnotationTransformers implementálja az IInvokedMethodListener { public void beforeInvocation(IInvokedMethod metódus, ITestResult testResult) { System.out.println(" ::: Mielőtt az IInvokedMethodListener metódusa aktiválódik a(z )(getTMethodMethodme(getTMethodme.(getTMethodMethodme)) nevű tesztmódszerhez. ) + " ::: "); } public void afterInvocation(IInvokedMethod metódus, ITestResult testResult) { System.out.println(" :::: Miután az IInvokedMethodListener metódusa aktiválódik a következőképpen nevezett tesztmódszerhez: " + method.getTestMethod().getMethodName() + ": :: "); } }
Itt van a tesztosztály a funkció teszteléséhez:
public class TestClassAnnotations { @Test(alwaysRun = true) public void testMethoddummy() { System.out.println("--- Ez egy tesztmódszer , amely az IInvokedMethodListener Testng Listener ---" funkcióját teszteli); } }
Meg kell említeni a TestNG iinvokedmethodlistenert a testng.xml figyelő címkéjében, mint mindig
<listeners>
<listener class-name="com.lambdageeks.CustomAnnotationTransformers"/>
</listeners>A végrehajtás kimenete így nézne ki:
::: Mielőtt az IInvokedMethodListener módszert elindítaná a következőképpen nevezett tesztmódszerhez: testMethoddummy :::
— Ez egy tesztmódszer, amely az IInvokedMethodListener Testng Listener funkcióját teszteli —
:::: Az IInvokedMethodListener metódusa után aktiválódik a : testMethoddummy nevű tesztmódszerhez :::
Hogyan lehet az adatszolgáltatókat implementálni a TestNG-be?
A DataProvider-t a TestNg segítségével az alábbi megközelítésben valósíthatjuk meg:
public class DataProviderDemo { @DataProvider(name = "dpName") public Object[][] dataProvidersMethodName() { return new Object[][]{{"Lambda"}, {"Geeks"}}; } @Test(dataProvider = "dpName") public void dataproviderDummyTestMethod(String dataValues) { System.out.println("Az adatparaméterek adatszolgáltatói példákkal : : " + adatértékek); } }
Ha nem állítjuk be a tesztmódszer prioritását, milyen sorrendben futnak le a tesztek a TestNG-ben?
A tesztek végrehajtása a Tesztmódszernév alfabatikus sorrendjében történik.
Például az alábbi kódrészletben:
public class SequenceTest { @Test() public void geeks() { System.out.println("Sequence Test , Method run :geeks "); } @Test() public void lambda() { System.out.println("Sekvencia teszt , Futott módszer : lambda "); } @Test() public void abc() { System.out.println("Sorozat teszt , Futott módszer :abc"); } }
A kimenet így nézne ki:
Szekvencia teszt, Futott módszer: abc
Szekvencia teszt , Futott módszer :geeks
Szekvencia teszt, Futott módszer: lambda
Hogyan lehet párhuzamosan futtatni a teszt szkripteket?
A Test szkripteket a TestNg XML fájl használatával futtathatja, ha megemlíti a parallel=”methods” thread-count=”2”, itt 2 párhuzamos eset kerül végrehajtásra , ha több szálat akarsz párhuzamosan végrehajtani.
<suite name="DummyTest" parallel="methods" thread-count="2" >
<listeners>
<listener class-name="org.uncommons.reportng.HTMLReporter" />
<listener class-name="org.uncommons.reportng.JUnitXMLReporter" />
</listeners>
</suite> Hogyan integrálható a TestNg a GRADLE build Tool-ba?
A Testng Suite programot a gradle-ben többféleképpen futtathatja:
A TestNg csoportok futtatása a Gradle használatával: A build.gradle fájlban létrehozhat egy feladatot, amely megemlítheti a useTestNG() és említse meg az alábbi részleteket a tesztcsoportok futtatása közben.
A Testng Default figyelő futtatása a Gradle-lel, hogy jelentést készítsen a TestNg könyvtár használatával
Ha az egyéni figyelőt szeretné használni, megemlítheti ugyanezt a következő megközelítésben:
Hogyan lehet futtatni a Testng Runner xml fájlt parancssor segítségével?
Használhatja a TestNg letöltött helyét, és megemlítheti az org.testng.TestNg.testNgRunner.xml fájlt a runner xml fájl futtatásához a parancssorból.
java -cp "/opt/testng-7.1.jar:bin" org.testng.TestNG testngRunner.xml
Hogyan integrálható a TestNg XML a Maven-nel?
A TestNg-t integrálhatja a Maven-nel az úgynevezett Plugin használatával maven-surefire-plugin ahol beállíthatja a testNgrunner.xml fájl futtatását a következő konfigurációk használatával:
Hogyan adhatja meg a TestNg Test paramétert a TestNg és a Maven használatával?
A Teszt paramétert a Maven SureFire Plugin és TestNg.XML fájl segítségével adhatja meg az alábbi módon
Testng Interjú kérdések és válaszok || 2. készlet
Mit jelent az invocationCount a TestNG-ben?
Az invocationCount egy tesztannotációs attribútum, amellyel meghatározhatja, hogy a tesztmetódus hány iterációt hajtson végre egyetlen végrehajtás során.
A fenti teszt kétszer fog lefutni, mivel az invocationCount értéke 2.
@Test(invocationCount = 2) public void testOfInvCount() { System.out.println("A meghívások számának tesztje folyamatban"); }
Mik a hallgatók a TestNG-ben?
A TestNg-ben a hallgatók alapvetően Java interfészek, amelyeket meg kell valósítani az osztályban. A megvalósított osztály folyamatosan figyel bizonyos eseményekre, és végrehajtja az adott eseményhez társított kódblokkot. Itt az interfész implementálásakor végül a nem implementált metódusokat implementálja, és ezek a kódblokkok vagy a metódusok akkor és amikor az adott esemény végrehajtásra kerülnek. aktiválódik.
A TestNG figyelők segítségével számos futásidejű műveletet hajthatunk végre a tesztszkript végrehajtása által kiváltott eltérő esemény és azok állapotának meghallgatásával, vagy készíthetünk jelentést. Ezenkívül megváltoztathatjuk a TestNg annotáció megvalósítását.
Említse meg a @Factory és a @Dataprovider megjegyzések közötti különbségeket a TestNg-ben?
@Dataprovider: Ha ugyanazt a tesztet szeretné végrehajtani, de minden futásban különböző adathalmazokkal, használhatja az adatszolgáltató annotációt, és ezzel elérheti az adatvezérelt tesztelési megközelítést. Itt a tesztmetódus végrehajtása ugyanazon osztálypéldány használatával történik, amelyhez a tesztmetódus tartozik.
@Factory: Ez a tesztosztályon belül található összes tesztmódszert végrehajtja az osztály különálló és több példányával.
Hogyan használjuk a TestNG Reporter Class-t a napló generálásához?
A részleteket és az adatokat a Reporter osztály segítségével naplózhatja, és ezeket a naplókat rögzíti a TestNG által generált jelentés
Reporter.log(" Naplózási üzenet ");
Hogyan lehet kivételkezelést végrehajtani a TestNG-ben?
Megemlítheti a várt kivétel típusát a expectExceptions nevű attribútumban a @test megjegyzéssel; ebben az esetben a TestNg sikeresnek jelöli a tesztet.
@Test(expectedExceptions = numberFormatException.class)
Hogyan lehet elérni a függőségi injekciót a TestNg XML-en keresztül?
A TestNG lehetővé teszi, hogy a TestNG XML fájlon keresztül függőségeket szúrjunk be a különböző tesztcsoportok közé. Amelyen keresztül elérhetjük, hogy az egyik csoport a másiktól függjön.
Melyek a TestNG különféle állítási megközelítései?
A TestNg-vel kétféle állítást használhatunk.
Soft Asserts
Kemény állítások
Említsen meg néhány gyakran használt állítást a TestNG-nél
Néhány széles körben használt állítási módszer a TestNG-ben:
- assertEquals (tényleges logikai érték, várható logikai érték)
- assertEqual (tényleges karakterlánc, várt karakterlánc)
- assertEqual (String tényleges eredmény, karakterlánc várt eredmény, karakterlánc üzenet)
- igazat állít (feltétel)
- assertFalse (feltétel)
- assertFalse (feltétel, üzenet)
- assertTrue (feltétel, üzenet)
Mit értesz a TestNG állításai alatt?
Egy állítást hajtanak végre a tényleges vizsgálati eredmények érvényesítésére a várt vizsgálati eredményekhez képest. A TestNg-ben használhatjuk a hard assert vagy a soft assert.
Különbség a kemény és lágy állítás között a TestNg-ben
A Hard assert-tel való munka során, ha az állítási feltételben bármilyen hibát kapunk, akkor a következő tesztlépések nem hajtódnak végre, és megszakadnak, és végül a teszt sikertelen tesztesetként lesz megjelölve.
Másrészt a Soft Assert figyelembe veszi az összes állítási pont érvényesítését, még akkor is, ha bármelyik állításban hiba van. Ez azt jelenti, hogy a teszt végrehajtása akkor sem szakad meg, ha az egyik állítás meghiúsul.
Hogyan írjunk lágy állítást a TestNg-ben
Az alábbi kódrészlet a lágy állítás megírásának megközelítését mutatja be TestNG-ben
@Test public void assertion() { SoftAssert softAssertion = new SoftAssert(); //1. állítás softAssertion.assertEquals("exp", "act"); //2. állítás softAssertion.assertEquals(123, 123); //3. állítás softAssertion.assertEquals("tényleges érték", "várható érték"); // A végén figyelembe véve az összes állítási értéket softAssertion.assertAll(); }
Hogyan használjunk reguláris kifejezést a TestNG csoportokban?
A TestNG-ben egy reguláris kifejezés használható a hasonló elnevezésű csoportok végrehajtására.
Ha például az összes „testX”-el kezdődő csoportot a név szerint futtatni szeretné, akkor a reguláris kifejezést testX.* néven használhatja a TestNG XML fájlban.
Testng Interjú kérdések és válaszok || 3. készlet
Mi az a TestNG?
A TestNg alapvetően a „Következő generáció tesztelése” egy egységtesztelési keretrendszer, amely a tesztautomatizálás és az automatizálási szkriptek folyását és sorrendjét szabályozza azáltal, hogy különféle megjegyzésekkel látja el azok funkcióit.
Mik a TestNg előnyei?
- A Testng különféle megjegyzései révén jobb megközelítésben szabályozhatja az automatizálás és a tesztvégrehajtás folyamatát és sorrendjét.
- Tesztosztályok vagy tesztszkript módszerek A TestNg segítségével párhuzamos végrehajtás érhető el.
- A TestNg könnyen integrálható különféle építőeszközökkel, mint például a Maven, Gradle. Ezenkívül integrálható a CICD-eszközökkel, például a Jenkins-szel.
- A TestNG részletes HTML jelentéskészítő funkciót biztosít, és könnyen integrálható más tesztjelentési platformokkal, mint például az Allure, az Extent Report a TestNG Listeners funkcióival.
- Az összes tesztet a testng.xml fájl indíthatja el, ahol megadhatja a futtatandó tesztosztály/teszt/tesztcsomag nevét.
- Adatvezérelt tesztelés a TestNg DataProvider annotációval végezhető el. A paraméterezési tesztek a Testng.xml-n keresztül is elvégezhetők, például a böngészők közötti tesztelés során paraméterezheti a különböző böngészőket különböző tesztekhez. Ez a funkció segít az adatvezérelt keretrendszer felépítésében a TestNG segítségével.
- TestNg Lehetővé teszi egy tesztkészlet felvételét/kizárását a tesngNg.xml fájlból az include és exkluzív attribútumokkal.
- A TestNg segítségével csoportosíthatja a teszteket és a függőségi injekciókat a tesztek között.
- A TestNg sok hallgató számára biztosít olyan dolgokat, amelyekkel sok mindent elérhet, például egyéni jelentéskészítést (IReporter), különböző eszközökkel való integrációt (ITestListener), a TestNG Test annotáció viselkedésének megváltoztatását futás közben az IAnnotationTransformer segítségével és még sok mást.
- Kihagyhatja az adott tesztet, rangsorolhatja a tesztrendelést, létrehozhat egy időhöz kötött tesztet a TestNg Test annotációkkal.
- Az Assert utasítás írásához használhatja a kemény állítást, valamint a lágy állítást a TestNg-vel.
- A TestNg minden tesztvégrehajtás után létrehozza a TestNG-failed.xml fájlt, így ugyanazt a létrehozott TestNG-failed.xml fájlt használhatja újra a sikertelen tesztparancsfájlok futtatásához.
- A TestNg különféle tesztannotációkat biztosít, például @BeforeMethod, @AfterMethod, @BeforeTest, @AfterTest.@BeforeSuite,@AfterSuite.
- A várt kivételt Test a TestNg segítségével futtathatja.
- A sikertelen tesztet újra lefuttathatja az IretryAnalyzer of Testng segítségével
Hogyan indítsa el és futtassa a TestNg tesztszkriptet?
A TestNg teszt szkriptet többféleképpen futtathatja:
- Kattintson a jobb gombbal a Tesztosztályra, majd a „Futtatás másként”, majd válassza a „TestNg Test” opciót.
- Hozzon létre testng.xml fájlt közvetlenül a fájlban, és futtassa az xml fájlt.
- Ha a testNg.xml fájlt integrálja a build eszközzel, például a Maven/Gradle-lel, akkor futhat a maven vagy a Gradle programból is.
- Ha az olyan összeállítási eszköz, mint a Maven/Gradle, integrálva van a CICD-vel, akkor futhat a CICD-ből, azaz a Jenkins-ből.
Adja meg a rendelkezésre álló Testng annotációkat?
A leggyakrabban használt Testng Test annotációk a következők:
- @BeforeSuite
- @AfterSuite
- @BeforeTest
- @AfterTest
- @Óra előtt
- @Óra után
- @BeforeMethod
- @AfterMethod
- @BeforeGroups
- @AfterGroups
- @Teszt
Megemlíti a TestNg annotációk végrehajtási sorrendjét?
Tesztvégrehajtás szempontjából az alábbi sorrend az összes elérhető TestNg megjegyzéshez:
Előfeltétel megjegyzések:
- @BeforeSuite
- @BeforeTest
- @Óra előtt
- @BeforeMethod
- Tesztjegyzetek:
- @Teszt
- Feltétel utáni megjegyzések:
- @AfterSuite
- @AfterTest
- @Óra után
- @AfterMethod
Hogyan lehet letiltani a tesztvégrehajtást egy tesztszkriptnél?
A @Test annotation attribútumban az engedélyezett attribútum értéke egyenlő a false értékkel, az alábbiak szerint:
@Test(enabled = false) public void logout(){ System.out.println("Mintateszt"); }
Hogyan adhat meg figyelőket a TestNG xml-ben?
Használhatja a Tesng xml fájlt a tesztszkript-végrehajtás részeként használandó figyelők megemlítésére, az alábbi megközelítésben:
...
Mi az időtúllépési teszt a TestNg-ben?
Ebben az esetben az „időtúllépési teszt” azt jelenti, hogy ha a tesztszkript végrehajtása a megadott időtartamnál tovább tart, akkor a testng megszakítja a tesztet, és sikertelen tesztként jelöli meg.
@Test(timeOut = 6000) // ezúttal többmásodpercben public void testShouldPass() InterruptedException { Thread.sleep(2000); }
Hogyan lehet elérni a várható kivételtesztet a TestNG segítségével?
Ha egy tesztmetódus kivételt dob, amely megegyezik az elvárt kivételek attribútum tesztannotációja részeként megadottal, akkor a TestNg sikeresnek jelöli a tesztet.
@Test(expectedExceptions = ArithmeticException.class) public void TestDivision() { int i = 1 / 0; }
A fenti tesztmódszert a rendszer átadja, mivel a TestNG által várt kivételt dobja ki.
Mi a különbség a @BeforeTest és a @BeforeMethod annotáció között?
A @BeforeTest minden teszt előtt egyszer lefut címke szerepel a testng.xml fájlban
A @BeforeMethod minden egyes tesztszkript metódus előtt lefut.
Milyen előnyökkel jár a testng.xml fájl használata?
A testng.xml fájl segítségével vezérelheti a végrehajtás folyamatát egyetlen tesztcsomaggal vagy több tesztcsomaggal egyetlen testng xml fájlban. Néhány fontos funkció:
- A testng.xml fájl lehetővé teszi számunkra, hogy kizárjuk és belefoglaljuk a tesztmódszereket és a tesztcsoport-végrehajtást.
- A tesztadatokat/paramétereket a testng.xml fájlon keresztül továbbíthatja.
- Felveheti a függőséget a vizsgálati módszerek és a vizsgálati módszerek egy csoportja között
- Részesítheti a teszteseteket.
- A tesztesetek párhuzamos tesztvégrehajtása valósul meg.
- Különféle testng figyelőket implementálhat és használhat, ha megemlíti azokat a testng.xml fájlban.
- Ha a programcsomagot a testng.xml-lel futtatja, akkor csak a következő iteráció tesztje sikertelen lesz, ha a TestNG-failed.xml fájlt minden végrehajtás után generálja.
- A segítségével meghatározott tesztcsoportokat futtathat TestNG xml címkéje.
Hány féle függőséget érhet el a TestNG használatával?
A TestNG segítségével kétféle függőséget érhetünk el:
A. Módszerektől függően:
Ennek a addictOnMethods attribútumnak a használatával meghatározhatja, hogy melyik vizsgálati módszer függjön más vizsgálati módszerektől, tehát ha a függő módszer sikertelen vagy nem fut, akkor a függő vizsgálati módszer sem fog futni.
@Test public void loginUserProfile() { System.out.println("Bejelentkezés felhasználó"); } @Test(dependsOnMethods = "loginUserProfile") public void logOutPage_user() { System.out.println("Felhasználó kijelentkezési oldala"); }
Itt található a logOutPage_user tesztmódszer, amely a loginUserProfile teszt sikeres végrehajtása után fut le.
B. a csoportoktól függ:
Az ilyen típusú tesztfüggőségben lehetővé teszi számunkra, hogy a vizsgálati módszerek függőségi injekcióját a vizsgálati módszerek csoportjába helyezzük.
A végrehajtás folyamata úgy történik, hogy először a testGroup indul és fut le, majd a függő tesztmódszer indul el, és a csoportteszt sikeres befejezése után a függő tesztmódszer kerül végrehajtásra.
@Test(groups="Tesztcsoportnév") public void testcaseOne() { System.out.println("testcaseOne folyamatban"); } @Test(groups="TesztCsoportnév") public void testcaseTwo() { System.out.println("tesztesetkét folyamatban"); } @Test(dependsOnGroups="TesztCsoportnév") public void testcaseThree() { System.out.println("TestcaseThree folyamatban"); }
Következtetés: Ezzel zárjuk a kritikus és fontosak listáját TestNg interjú kérdések és válaszok , a TestNg jobb tapadása érdekében végighaladhat a kimerítő dokumentáció a TestNg-ről.
Ha többet szeretne megtudni a kimerítő Selenium oktatóanyag, amelyet itt tekinthet meg.
