สูงสุด 50 TestNG คำถามและคำตอบในการสัมภาษณ์ (2026)

โดย: Krishna รุ่งทา Krishna รุ่งทา
Hours วันที่อัพเดท

Top TestNG คำถามและคำตอบสัมภาษณ์

เตรียมความพร้อม TestNG กำลังสัมภาษณ์งานอยู่ใช่ไหม? ถึงเวลาแล้วที่จะพิจารณาคำถามที่แสดงให้เห็นถึงจุดแข็งของคุณ การสัมภาษณ์ที่ดี TestNG พื้นฐานการสัมภาษณ์แสดงให้เห็นถึงความลึกซึ้ง ความมั่นใจ และความพร้อม ซึ่งเป็นสิ่งที่ทีมคัดเลือกบุคลากรให้ความสำคัญ

โอกาสในสายงานนี้ครอบคลุมถึงการเติบโตของระบบอัตโนมัติ เฟรมเวิร์กที่กำลังพัฒนา และแอปพลิเคชันการทดสอบเชิงปฏิบัติ ซึ่งต้องอาศัยประสบการณ์ทางเทคนิคและวิชาชีพ การทำงานในสาขานี้ต้องการความเชี่ยวชาญเฉพาะด้าน ทักษะการวิเคราะห์ และทักษะที่ยืดหยุ่น ซึ่งช่วยให้ผู้เริ่มต้น ผู้ที่มีประสบการณ์ระดับกลาง และผู้เชี่ยวชาญระดับสูง สามารถตอบคำถามและข้อสงสัยยอดนิยมทั่วไปในด้านเทคนิค พื้นฐาน และขั้นสูงได้ อ่านเพิ่มเติม ...

👉 ดาวน์โหลด PDF ฟรี: TestNG คำถามและคำตอบในการสัมภาษณ์

Top TestNG คำถามและคำตอบสัมภาษณ์

1) คืออะไร TestNG แล้วทำไมจึงนำมาใช้ในการทดสอบแบบอัตโนมัติ?

TestNG (Test Next Generation) คือเฟรมเวิร์กการทดสอบที่ได้รับแรงบันดาลใจจาก JUnit และ NUnit แต่ได้รับการพัฒนาเพิ่มเติมด้วยความสามารถขั้นสูง เช่น การจัดกลุ่ม การจัดลำดับ การกำหนดพารามิเตอร์ และการจัดการการพึ่งพา โดยส่วนใหญ่ใช้ในการทดสอบอัตโนมัติเพื่อเพิ่มประสิทธิภาพการดำเนินการทดสอบ ปรับปรุงการจัดระเบียบการทดสอบ และสร้างรายงาน HTML และ XML ที่ละเอียด

ประโยชน์หลักของ TestNG รวมถึง:

  • รองรับ การดำเนินการทดสอบแบบขนานซึ่งจะช่วยลดเวลาการทำงานโดยรวมลง
  • ให้ คำอธิบายประกอบ ที่ควบคุมขั้นตอนการทดสอบได้อย่างมีประสิทธิภาพ
  • เสนอ การทดสอบที่ขับเคลื่อนด้วยข้อมูล ผ่าน @DataProvider คำอธิบายประกอบ
  • สร้าง รายงานที่ปรับแต่งได้ เพื่อการแก้ไขข้อผิดพลาดที่ดีขึ้น

ตัวอย่างเช่น TestNG ช่วยให้คุณสามารถเรียกใช้กลุ่มทดสอบแบบ Smoke Test, Regression Test และ Integration Test ได้อย่างอิสระโดยไม่ต้องแก้ไขโค้ดทดสอบ ซึ่งมอบความยืดหยุ่นและความสามารถในการขยายขนาดในชุดทดสอบอัตโนมัติขนาดใหญ่

2) อธิบาย TestNG วงจรชีวิตพร้อมคำอธิบายประกอบและลำดับการดำเนินการ

การขอ TestNG วงจรชีวิต (lifecycle) กำหนดวิธีการเริ่มต้น ดำเนินการ และยุติการทดสอบ โดยควบคุมผ่านคำอธิบายประกอบ (annotations) ที่ให้โครงสร้างและความชัดเจนแก่ขั้นตอนการทดสอบ

คำอธิบายประกอบ Descriptไอออน คำสั่งดำเนินการ
@BeforeSuite รันก่อนการทดสอบทั้งหมดในชุดทดสอบ 1
@BeforeTest ดำเนินการก่อน <test> แท็กใน XML 2
@BeforeClass ทำงานก่อนเมธอดแรกในคลาสปัจจุบัน 3
@BeforeMethod ดำเนินการก่อนวิธีทดสอบแต่ละวิธี 4
@Test ประกอบด้วยตรรกะการทดสอบจริง 5
@AfterMethod รันหลังจากวิธีการทดสอบแต่ละวิธี 6
@AfterClass ทำงานหลังจากเรียกใช้เมธอดทั้งหมดในคลาส 7
@AfterTest วิ่งตาม <test> แท็กใน XML 8
@AfterSuite ดำเนินการหลังจากการทดสอบทั้งหมดในชุดโปรแกรม 9

ลำดับขั้นตอนที่เป็นระบบนี้ช่วยให้การตั้งค่าและการยุติการทดสอบเป็นไปอย่างคาดการณ์ได้ ซึ่งเป็นสิ่งสำคัญสำหรับการรักษาความเป็นอิสระของการทดสอบ

3) เป็นอย่างไรบ้าง TestNG แตกต่างจาก JUnit?

แม้ว่าทั้งสองเฟรมเวิร์กจะใช้สำหรับการทดสอบหน่วยก็ตาม TestNG ช่วยให้สามารถกำหนดค่าและประมวลผลแบบขนานได้อย่างมีประสิทธิภาพยิ่งขึ้น

ลักษณะ JUnit TestNG
การดำเนินการแบบขนาน การสนับสนุนที่ จำกัด สนับสนุนอย่างเต็มที่
คำอธิบายประกอบ น้อยลง (@Before, @After) รวยกว่า (@BeforeSuite, @DataProvider)
การจัดการการพึ่งพา ไม่สามารถใช้ได้ สามารถใช้งานได้โดยใช้ dependsOnMethods
หมวดหมู่ ไม่ได้รับการสนับสนุน รองรับการใช้งาน groups
การกำหนดพารามิเตอร์ ผ่านทางตัววิ่งภายนอก สร้างขึ้นโดยใช้ XML หรือ @DataProvider

สรุป, TestNG เป็นที่ต้องการสำหรับ การทดสอบระบบอัตโนมัติระดับองค์กร และการบูรณาการกับเครื่องมือต่างๆ เช่น Selenium, ในขณะที่ JUnit เหมาะอย่างยิ่งสำหรับการทดสอบหน่วยแบบง่ายๆ

4) คืออะไร TestNG คำอธิบายประกอบมีประโยชน์อย่างไร?

คำอธิบายประกอบใน TestNG กำหนด โครงสร้างและพฤติกรรมของวิธีการทดสอบพวกมันช่วยลดความจำเป็นในการกำหนดค่า XML ที่ซับซ้อนโดยการให้การควบคุมการทดสอบแบบประกาศโดยตรงในโค้ด

คำอธิบายประกอบที่ใช้กันทั่วไป ได้แก่:

  • @BeforeSuite, @BeforeTest, @BeforeClass, @BeforeMethod
  • @Test
  • @AfterMethod, @AfterClass, @AfterTest, @AfterSuite

ตัวอย่าง:

@BeforeMethod
public void setup() {
    System.out.println("Initializing browser...");
}

@Test
public void verifyLogin() {
    System.out.println("Executing login test...");
}

วิธีนี้ช่วยให้นักพัฒนาสามารถจัดระเบียบการดำเนินการทดสอบได้อย่างเป็นระบบ ทำให้มั่นใจได้ว่าการตั้งค่า การดำเนินการทดสอบ และการยกเลิกการตั้งค่าจะเกิดขึ้นตามลำดับที่กำหนดไว้

5) อธิบายแนวคิดเรื่องการจัดกลุ่มใน TestNG.

การจัดกลุ่มใน TestNG ช่วยให้สามารถจัดหมวดหมู่การทดสอบอย่างเป็นระบบออกเป็นชุดย่อยที่จัดการได้ง่าย เช่น "การทดสอบควัน" "การทดสอบการถดถอย" หรือ "การทดสอบความปกติ"

ตัวอย่าง:

@Test(groups = {"Smoke"})
public void loginTest() { ... }
@Test(groups = {"Regression"})
public void paymentTest() { ... }

คุณสามารถกำหนดค่าชุดทดสอบ XML ของคุณให้ทำงานกับกลุ่มเฉพาะได้:

<groups>
  <run>
    <include name="Smoke"/>
  </run>
</groups>

ประโยชน์ที่ได้รับ:

  • ช่วยให้สามารถเลือกดำเนินการทดสอบได้ตามต้องการ
  • เพิ่มความยืดหยุ่นในกระบวนการ CI/CD
  • ช่วยประหยัดเวลาในการดำเนินการระหว่างการสร้างแบบเพิ่มทีละส่วน

6) จะสามารถกำหนดพารามิเตอร์ได้อย่างไรใน TestNG?

การกำหนดพารามิเตอร์ช่วยให้การทดสอบเป็นไปตามข้อมูลเป็นหลัก ทำให้สามารถเรียกใช้การทดสอบด้วยชุดข้อมูลอินพุตหลายชุดได้ TestNG รองรับสองวิธีหลัก:

  1. การใช้ @Parameters การใส่คำอธิบายประกอบด้วย XML:
    2. <parameter name="browser" value="chrome"/>
@Test
@Parameters("browser")
public void launchBrowser(String browser) { ... }
  2. การใช้ @DataProvider:
    3. @DataProvider(name="loginData")
public Object[][] getData() {
  return new Object[][] {{"user1","pass1"}, {"user2","pass2"}};
}

@Test(dataProvider="loginData")
public void loginTest(String user, String pass) { ... }

ความยืดหยุ่นนี้ทำให้การบำรุงรักษาและการดำเนินการชุดทดสอบขนาดใหญ่ในสภาพแวดล้อมหรือการกำหนดค่าต่างๆ ทำได้ง่ายขึ้น

7) ความสัมพันธ์แบบพึ่งพาใน คืออะไร TestNG แล้วพวกเขาได้รับการจัดการอย่างไร?

การพึ่งพาใน TestNG ควบคุมลำดับการดำเนินการทดสอบโดยอิงจากผลการทดสอบอื่นๆ โดยใช้ dependsOnMethods or dependsOnGroups แอตทริบิวต์

ตัวอย่าง:

@Test
public void loginTest() { ... }

@Test(dependsOnMethods = {"loginTest"})
public void verifyDashboard() { ... }

หากเมธอดที่เกี่ยวข้องล้มเหลว การทดสอบในขั้นตอนถัดไปจะถูกข้ามไปโดยอัตโนมัติ

กลไกนี้ช่วยป้องกันการดำเนินการทดสอบที่ไม่ถูกต้องและช่วยรักษาประสิทธิภาพ ความสมบูรณ์ของการทดสอบเชิงตรรกะโดยเฉพาะอย่างยิ่งมีประโยชน์สำหรับขั้นตอนการทำงานหลายขั้นตอน เช่น เข้าสู่ระบบ → ดำเนินการ → ตรวจสอบผลลัพธ์

บทความที่เกี่ยวข้อง

8) มีวิธีการดำเนินการที่แตกต่างกันอย่างไรบ้าง TestNG การทดสอบ?

TestNG การทดสอบสามารถดำเนินการได้หลายวิธีอย่างยืดหยุ่น ขึ้นอยู่กับการตั้งค่าการทดสอบ:

  1. จาก IDE (Eclipse/IntelliJ): คลิกขวาที่คลาสหรือ XML file → Run as → TestNG Test.
  2. จากบรรทัดคำสั่ง: java -cp "path\testng.jar;bin" org.testng.TestNG testng.xml
  3. การใช้เครื่องมือสร้างโปรแกรม:
    • มาเวน: กำหนดค่า surefire-plugin in pom.xml.
    • Gradle: ใช้ testng การกำหนดค่าการพึ่งพาและงาน
  4. ผ่านทาง CI/CD Pipelines: ผสานการทำงานกับ Jenkins หรือ GitHub Actions เพื่อการดำเนินการอัตโนมัติ

ความหลากหลายนี้ช่วยให้มั่นใจได้ถึงความเข้ากันได้ในสภาพแวดล้อมการพัฒนา การทดสอบ และการใช้งานจริง

9) คืออะไร TestNG ผู้ฟังและเหตุใดพวกเขาจึงมีความสำคัญ?

ผู้ฟังใน TestNG จัดเตรียมกลไกเพื่อปรับแต่งพฤติกรรมการทดสอบโดยการตรวจสอบเหตุการณ์การดำเนินการทดสอบ เช่น การเริ่มต้น ความสำเร็จ ความล้มเหลว หรือการข้าม

กลุ่มผู้ฟังทั่วไป:

  • ITestListener: ติดตามเหตุการณ์ระดับวิธีการทดสอบ
  • ISuiteListener: สังเกตการณ์เหตุการณ์ระดับชุดโปรแกรม
  • IReporter: สร้างรายงานแบบกำหนดเอง

ตัวอย่าง:

public class CustomListener implements ITestListener {
  public void onTestFailure(ITestResult result) {
    System.out.println("Test Failed: " + result.getName());
  }
}

ผู้ฟังมักถูกใช้เพื่อรับฟัง ภาพหน้าจอเมื่อเกิดความล้มเหลว, กำลังสร้าง บันทึกแบบกำหนดเองหรือ การบูรณาการกับเครื่องมือการรายงาน เช่น Allure หรือ ExtentReports

10) ข้อดีและข้อเสียของการใช้มีอะไรบ้าง TestNG?

แง่มุม ข้อดี ข้อเสีย
ความยืดหยุ่น รองรับการจัดกลุ่ม การพึ่งพา และการประมวลผลแบบขนาน การตั้งค่า XML ที่ซับซ้อนสำหรับชุดทดสอบขนาดใหญ่
การรายงาน จัดทำรายงานในรูปแบบ HTML และ XML ที่ละเอียดครบถ้วน การปรับแต่งที่จำกัดหากไม่มีผู้ฟัง
บูรณาการ ทำงานได้อย่างราบรื่นด้วย Selenium และเครื่องมือ CI/CD ต้องใช้เวลาเรียนรู้ค่อนข้างนานกว่าเล็กน้อย
การกำหนดพารามิเตอร์ มีระบบรองรับการทดสอบที่ขับเคลื่อนด้วยข้อมูลในตัว จำเป็นต้องมีการบำรุงรักษาสำหรับชุดข้อมูลขนาดใหญ่

รวม, TestNG เป็นเฟรมเวิร์กที่แข็งแกร่งและยืดหยุ่น เหมาะสำหรับสภาพแวดล้อมการทดสอบอัตโนมัติสมัยใหม่ แม้จะมีค่าใช้จ่ายในการกำหนดค่าเพียงเล็กน้อยก็ตาม

11) คุณจะจัดลำดับความสำคัญของกรณีทดสอบได้อย่างไร TestNG?

TestNG ให้ priority คุณลักษณะใน @Test คำอธิบายประกอบเพื่อกำหนดลำดับการทำงานของเมธอดทดสอบ โดยการทดสอบที่มีลำดับความสำคัญต่ำกว่าจะทำงานก่อน

ตัวอย่าง:

@Test(priority = 1)
public void loginTest() { ... }

@Test(priority = 2)
public void dashboardTest() { ... }

หากไม่ได้ระบุลำดับความสำคัญ ค่าเริ่มต้นคือ 0และเมธอดต่างๆ จะทำงานตามลำดับตัวอักษร

ปฏิบัติที่ดีที่สุด: ควรใช้ค่าลำดับความสำคัญอย่างระมัดระวัง การใช้ค่าลำดับความสำคัญมากเกินไปอาจทำให้ลำดับการทดสอบไม่ยืดหยุ่น สำหรับขั้นตอนที่ซับซ้อน ควรจัดการความสัมพันธ์ระหว่างขั้นตอน (dependsOnMethods) ดูแลรักษาง่ายกว่าการจัดลำดับความสำคัญอย่างเคร่งครัด

12) อธิบายแนวคิดและการใช้งานการประมวลผลแบบขนานใน TestNG.

การดำเนินการแบบคู่ขนานใน TestNG ช่วยให้สามารถเรียกใช้การทดสอบ คลาส หรือเมธอดหลายรายการพร้อมกันได้ ซึ่งช่วยลดเวลาในการประมวลผลโดยรวมได้อย่างมาก

คุณสามารถเปิดใช้งานฟีเจอร์นี้ได้ใน testng.xml ไฟล์:

<suite name="ParallelSuite" parallel="tests" thread-count="3">
  <test name="Test1">...</test>
  <test name="Test2">...</test>
</suite>

รองรับโหมดขนาน:

  • tests
  • classes
  • methods
  • instances

ข้อดี:

  • รอบการตอบรับที่รวดเร็วยิ่งขึ้น
  • การใช้ประโยชน์จากโปรเซสเซอร์มัลติคอร์อย่างมีประสิทธิภาพ
  • ความสามารถในการปรับขนาดสำหรับชุดซอฟต์แวร์อัตโนมัติขนาดใหญ่

อย่างไรก็ตาม โปรดตรวจสอบให้แน่ใจว่า ความปลอดภัยของเกลียว เมื่อใช้ทรัพยากรที่ใช้ร่วมกัน เช่น WebDriver หรือการเชื่อมต่อฐานข้อมูล

13) ผู้ให้บริการข้อมูลใน... คืออะไร TestNG? พวกมันแตกต่างจากพารามิเตอร์อย่างไร?

@DataProvider ช่วยให้ การทดสอบที่ขับเคลื่อนด้วยข้อมูล โดยการจัดหาวิธีการทดสอบที่มีชุดข้อมูลหลายชุด

ตัวอย่าง:

@DataProvider(name="credentials")
public Object[][] data() {
    return new Object[][] {{"user1", "pass1"}, {"user2", "pass2"}};
}

@Test(dataProvider="credentials")
public void login(String username, String password) { ... }

ความแตกต่างระหว่าง @Parameters และ @DataProvider:

ลักษณะ @Parameters @DataProvider
แหล่งข้อมูล ไฟล์ XML Java วิธี
ประเภทข้อมูล ชุดข้อมูลเดียว ชุดข้อมูลหลายชุด
ความยืดหยุ่น Less จุดสูง
ใช้กรณี ตัวแปรสภาพแวดล้อม การทดสอบที่ขับเคลื่อนด้วยข้อมูลซ้ำๆ

ดังนั้น @DataProvider วิธีนี้เหมาะสมกว่าเมื่อทำการทดสอบเพียงครั้งเดียวกับชุดข้อมูลหลายชุด เช่น การตรวจสอบการเข้าสู่ระบบด้วยข้อมูลประจำตัวหลายชุด

14) คุณจะปิดใช้งานหรือข้ามการทดสอบได้อย่างไร TestNG?

คุณสามารถปิดใช้งานการทดสอบได้ใน TestNG โดยใช้โปรแกรม enabled ระบุคุณลักษณะ หรือโดยการข้ามไปโดยใช้โปรแกรม

1 ใช้ enabled = false:

@Test(enabled = false)
public void skipTest() {
    System.out.println("This test will not run.");
}

2. การข้ามระหว่างการทำงานโดยใช้ SkipException:

@Test
public void conditionalSkip() {
    throw new SkipException("Skipping this test due to condition.");
}

การปิดใช้งานมีประโยชน์สำหรับ ปิดใช้งานชั่วคราว การทดสอบที่ไม่เสถียรหรือไม่สมบูรณ์โดยไม่ต้องลบออก การข้ามการทดสอบนั้นมีประโยชน์สำหรับ เงื่อนไขขณะรันไทม์เช่น การข้ามการทดสอบสำหรับเบราว์เซอร์ที่ไม่รองรับ

15) ไฟล์ testng.xml มีบทบาทอย่างไร และมีส่วนประกอบหลักอะไรบ้าง?

การขอ testng.xml ไฟล์นี้เป็นแกนหลักของการกำหนดค่าของ TestNGโดยจะกำหนดชุดทดสอบ กลุ่มทดสอบ พารามิเตอร์ และการตั้งค่าการประมวลผลแบบขนาน

ตัวอย่างโครงสร้าง:

<suite name="AutomationSuite">
  <parameter name="browser" value="chrome"/>
  <test name="RegressionTests">
    <classes>
      <class name="com.test.LoginTest"/>
      <class name="com.test.PaymentTest"/>
    </classes>
  </test>
</suite>

ส่วนประกอบหลัก:

  • <suite> – กำหนดรายละเอียดของชุดโปรแกรมทั้งหมด
  • <test> – แสดงถึงบล็อกทดสอบ
  • <classes> – แสดงรายการคลาสทดสอบ
  • <methods> – กรองวิธีการทดสอบเฉพาะบางวิธี
  • <parameter> – ระบุพารามิเตอร์ระดับสากลหรือระดับการทดสอบ

ไฟล์ XML ให้ข้อมูล การควบคุมจากส่วนกลาง การทำงานเกินขีดจำกัดโดยไม่เปลี่ยนแปลงโค้ด

16) คุณสามารถสร้างรายงานใน ได้อย่างไร TestNG?

TestNG สร้างโดยอัตโนมัติ รายงานสองประเภท:

  1. รายงาน HTML (test-output/index.html– สรุปผลการสอบที่ผ่าน ไม่ผ่าน และข้ามการสอบ
  2. รายงาน XML – ใช้สำหรับการบูรณาการกับเครื่องมือ CI/CD

สำหรับการรายงานขั้นสูง TestNG ผสานรวมกับ:

  • รายงานขอบเขต – นำเสนอแดชบอร์ดแบบกราฟิกและบันทึกข้อมูลโดยละเอียด
  • รายงานจาก Allure – นำเสนอการวิเคราะห์เชิงภาพด้วยขั้นตอนการทดสอบ ภาพหน้าจอ และบันทึกต่างๆ

ตัวอย่างการบูรณาการ:

ExtentReports extent = new ExtentReports();
ExtentTest test = extent.createTest("Login Test");
test.pass("Test Passed Successfully");
extent.flush();

รายงานเหล่านี้มีความสำคัญอย่างยิ่งสำหรับการติดตามแนวโน้มและระบุจุดอ่อนในการครอบคลุมการทดสอบ

17) โรงงานใน... TestNGและพวกเขาทำงานอย่างไร?

โรงงานใน TestNG ใช้ในการสร้าง อินสแตนซ์แบบไดนามิกของคลาสทดสอบ. วิธีการนี้อนุญาตให้สร้างอินสแตนซ์ของคลาสโดยใช้พารามิเตอร์ก่อนที่จะทำการทดสอบ

ตัวอย่าง:

public class FactoryExample {
  private String browser;

  public FactoryExample(String browser) {
    this.browser = browser;
  }

  @Factory
  public static Object[] factoryMethod() {
    return new Object[] { new FactoryExample("Chrome"), new FactoryExample("Firefox") };
  }

  @Test
  public void testBrowser() {
    System.out.println("Running test on: " + browser);
  }
}

ข้อดี:

  • ช่วยให้ การสร้างวัตถุแบบพารามิเตอร์.
  • เหมาะอย่างยิ่งสำหรับ การทดสอบข้ามเบราว์เซอร์ และ การดำเนินการหลายสภาพแวดล้อม.
    Factories เป็นส่วนเสริมของ DataProviders เมื่อคุณต้องการการกำหนดค่าอ็อบเจ็กต์ที่แตกต่างกัน แทนที่จะเป็นการเปลี่ยนแปลงข้อมูลในระดับเมธอดเพียงอย่างเดียว

18) คุณสามารถใช้การยืนยัน (assertions) ในวิธีใดได้บ้าง TestNG?

การยืนยันผลลัพธ์ใช้เพื่อเปรียบเทียบผลลัพธ์ที่คาดหวังกับผลลัพธ์ที่เกิดขึ้นจริงภายในวิธีการทดสอบ

ประเภทของการยืนยัน:

  1. การตรวจสอบแบบเข้มงวด (คลาส Assert):
    หยุดการทดสอบทันทีเมื่อเกิดข้อผิดพลาด
    2. Assert.assertEquals(actual, expected);
Assert.assertTrue(condition);
  2. การตรวจสอบแบบอ่อน (คลาส SoftAssert):
    ดำเนินการต่อไปแม้ว่าจะเกิดข้อผิดพลาด และรายงานปัญหาทั้งหมดในตอนท้าย
    3. SoftAssert soft = new SoftAssert();
    soft.assertEquals(actual, expected);
    soft.assertAll();
  3. ควรใช้เมื่อใด:
    • ใช้การยืนยันที่เข้มงวดสำหรับ การตรวจสอบความถูกต้องที่สำคัญ เช่น เข้าสู่ระบบสำเร็จ
    • ใช้การยืนยันแบบนุ่มนวลสำหรับ การตรวจสอบหลายรายการ ภายในวิธีการทดสอบเดียว

19) อธิบายความแตกต่างระหว่าง @BeforeMethod และ @BeforeClass ใน TestNG.

แง่มุม @BeforeMethod @BeforeClass
การกระทำ วิ่ง ก่อนแต่ละครั้ง วิธีทดสอบ วิ่ง ครั้งก่อน เมธอดใดๆ ในคลาส
ขอบเขต ต่อวิธีการทดสอบ ต่อคลาสทดสอบ
การใช้งานทั่วไป เริ่มต้นการทำงานของเบราว์เซอร์ก่อนการทดสอบทุกครั้ง กำลังโหลดการตั้งค่าหรือการตั้งค่าเบราว์เซอร์หนึ่งครั้ง

ตัวอย่าง:

@BeforeClass
public void setupClass() {
    System.out.println("Executed once per class");
}

@BeforeMethod
public void setupMethod() {
    System.out.println("Executed before each method");
}

ใช้ @BeforeMethod เมื่อการทดสอบแต่ละครั้งต้องการสภาพแวดล้อมที่สะอาด และ @BeforeClass สำหรับงานเริ่มต้นระบบขนาดใหญ่ที่สามารถนำกลับมาใช้ใหม่ได้

20) เป็นยังไงบ้าง TestNG รองรับ Dependency Injection และมีกรณีการใช้งานอะไรบ้าง?

TestNG สนับสนุน การฉีดพึ่งพา ผ่านการแทรกบริบทและวัตถุการกำหนดค่าในตัว เช่น ITestContext, XmlTestหรือ Method.

ตัวอย่าง:

@Test
public void testContextExample(ITestContext context) {
    System.out.println("Suite Name: " + context.getSuite().getName());
}

ใช้กรณี:

  • ดึงค่าพารามิเตอร์การทดสอบแบบไดนามิก
  • การเข้าถึงข้อมูลการกำหนดค่า เช่น ชื่อชุดโปรแกรม หรือการตั้งค่าการประมวลผลแบบขนาน
  • เพิ่มความยืดหยุ่นในการทดสอบโดยไม่ต้องกำหนดค่าการพึ่งพาแบบตายตัว

การฉีดการพึ่งพา (Dependency injection) ช่วยให้นักพัฒนาสามารถ เขียนชุดทดสอบแบบแยกส่วนและคำนึงถึงบริบท ที่ปรับตัวได้อย่างยืดหยุ่นต่อการเปลี่ยนแปลงของสภาพแวดล้อม

21) @Factory กับ @DataProvider ต่างกันอย่างไร TestNG?

ทั้งสอง @Factory และ @DataProvider ช่วยในการกำหนดพารามิเตอร์ แต่พวกมันทำงานที่ ระดับที่แตกต่างกัน ในสถาปัตยกรรมการทดสอบ

ลักษณะ @Factory @DataProvider
ขอบเขต ระดับชั้นเรียน ระดับวิธีการ
จุดมุ่งหมาย สร้างอินสแตนซ์หลายตัวของคลาสโดยใช้ข้อมูลที่แตกต่างกัน จัดหาข้อมูลให้กับวิธีการทดสอบเพียงวิธีเดียว
การกระทำ เรียกใช้คลาสทั้งหมดสำหรับแต่ละอินสแตนซ์ เรียกใช้เมธอดหนึ่งซ้ำหลายครั้ง
กรณีการใช้งานในอุดมคติ การทดสอบข้ามเบราว์เซอร์หรือสภาพแวดล้อม การทดสอบการทำงานโดยใช้ข้อมูลเป็นหลัก

ตัวอย่าง:

  • ผลิตจากโรงงาน: เรียกใช้คลาสทั้งหมดสำหรับแต่ละประเภทของเบราว์เซอร์
  • ผู้ให้บริการข้อมูล: เรียกใช้เมธอดทดสอบหนึ่งวิธีกับชุดข้อมูลหลายชุด

ใช้ @Factory เมื่อการสร้างอินสแตนซ์ของวัตถุนั้นเปลี่ยนแปลงไป และ @DataProvider สำหรับการเปลี่ยนแปลงอินพุตเชิงฟังก์ชันภายในอินสแตนซ์วัตถุเดียวกัน

22) คุณจะลองทดสอบกรณีที่ล้มเหลวซ้ำโดยอัตโนมัติได้อย่างไร TestNG?

TestNG จัดเตรียมกลไกเพื่อ เรียกใช้กรณีทดสอบที่ล้มเหลวซ้ำ โดยใช้โปรแกรม IRetryAnalyzer อินเตอร์เฟซ.

ตัวอย่างการใช้งาน:

public class RetryAnalyzer implements IRetryAnalyzer {
  int count = 0;
  int maxTry = 2;

  public boolean retry(ITestResult result) {
    if (count < maxTry) {
      count++;
      return true;
    }
    return false;
  }
}

การใช้งาน:

@Test(retryAnalyzer = RetryAnalyzer.class)
public void testLogin() {
   Assert.fail("Intentional Failure");
}

ประโยชน์ที่ได้รับ:

  • ช่วยลดความไม่เสถียรในกระบวนการ CI (Continuous Integration)
  • จัดการกับปัญหาเครือข่ายหรือสภาพแวดล้อมชั่วคราว

ปฏิบัติที่ดีที่สุด: ผสานตรรกะการลองใหม่เข้ากับการบันทึกข้อมูลและการจับภาพหน้าจออย่างเหมาะสมเพื่อช่วยในการแก้ไขข้อผิดพลาดที่เกิดขึ้นเป็นระยะๆ

23) ITestContext มีประโยชน์อย่างไรใน TestNG?

ITestContext ให้ ข้อมูลเชิงบริบท เกี่ยวกับการดำเนินการทดสอบ รวมถึงชื่อชุดทดสอบ ชื่อการทดสอบ โฟลเดอร์เอาต์พุต และพารามิเตอร์

ตัวอย่าง:

@Test
public void contextExample(ITestContext context) {
    System.out.println("Suite: " + context.getSuite().getName());
}

วิธีการสำคัญ:

  • getSuite() – ดึงข้อมูลระดับห้องชุด
  • getName() – ส่งคืนชื่อของการทดสอบ
  • setAttribute() / getAttribute() – แชร์ข้อมูลระหว่างการทดสอบต่างๆ

มันเปิดใช้งาน การแชร์ข้อมูลระหว่างวิธีการทดสอบหรือคลาสต่างๆ และช่วยให้สามารถสร้างรายงานและบันทึกข้อมูลได้อย่างมีประสิทธิภาพ

24) คุณจะสร้างความสัมพันธ์ระหว่างกลุ่มทดสอบได้อย่างไร TestNG?

คุณสามารถกำหนดความสัมพันธ์ระหว่างกลุ่มได้โดยใช้ dependsOnGroups คุณลักษณะใน @Test คำอธิบายประกอบ

ตัวอย่าง:

@Test(groups = "Login")
public void login() { ... }

@Test(dependsOnGroups = "Login")
public void verifyProfile() { ... }

สิ่งนี้ทำให้มั่นใจได้ว่า verifyProfile กลุ่มจะทำงานก็ต่อเมื่อผ่านการทดสอบทั้งหมดแล้วเท่านั้น Login กลุ่มดังกล่าวผ่านด่านเรียบร้อยแล้ว

มีประโยชน์อย่างยิ่งใน การทดสอบการรวมโดยที่โมดูลต่างๆ ขึ้นอยู่กับการทำงานที่สำเร็จของโมดูลอื่นๆ (เช่น ขั้นตอนการเข้าสู่ระบบ → การตั้งค่าโปรไฟล์ → การออกจากระบบ)

25) คุณจะเพิกเฉยต่อวิธีการทดสอบบางอย่างได้อย่างไร TestNG ไฟล์ XML?

ได้อย่างชัดเจน ไม่รวมวิธีการ ภายในคลาสในไฟล์ชุด XML โดยใช้ <exclude> แท็ก

ตัวอย่าง:

<class name="com.test.LoginTests">
  <methods>
    <exclude name="verifyLogout"/>
  </methods>
</class>

สิ่งนี้ช่วยให้ผู้ทดสอบสามารถ ปิดใช้งานวิธีการเฉพาะบางอย่างชั่วคราว โดยไม่ต้องแก้ไข Java ซอร์สโค้ด — มีประโยชน์ในชุดซอฟต์แวร์ขนาดใหญ่ที่ต้องการการรวมหรือการแยกส่วนแบบไดนามิกตามรอบการเผยแพร่หรือลำดับความสำคัญของสปรินต์

26) ทำอย่างไรได้ TestNG บูรณาการกับ Selenium เว็บไดร์เวอร์?

TestNG และ Selenium เป็นการผสมผสานที่มีประสิทธิภาพสำหรับการทำงานอัตโนมัติของ UI

โดยทั่วไป การตั้งค่าการบูรณาการจะเกี่ยวข้องกับการจัดระเบียบการทดสอบโดยใช้คำอธิบายประกอบ การจัดการการตั้งค่า/การยกเลิกการตั้งค่า และการเรียกใช้การทดสอบผ่าน XML หรือเครื่องมือ CI

ตัวอย่าง:

@BeforeMethod
public void setup() {
    driver = new ChromeDriver();
}

@Test
public void verifyTitle() {
    driver.get("https://example.com");
    Assert.assertEquals(driver.getTitle(), "Example Domain");
}

@AfterMethod
public void teardown() {
    driver.quit();
}

ประโยชน์ของการบูรณาการ:

  • ช่วยให้ การทดสอบเบราว์เซอร์แบบขนาน.
  • ช่วยลดความยุ่งยาก การจัดกลุ่มทดสอบและการรายงาน.
  • ทำงานได้อย่างราบรื่นด้วย ท่อ CI / CD เช่น Jenkins หรือ GitHub Actions

27) แนวทางปฏิบัติที่ดีที่สุดเมื่อใช้งานมีอะไรบ้าง TestNG ในเฟรมเวิร์กการทำงานอัตโนมัติขนาดใหญ่?

ปฏิบัติที่ดีที่สุด:

  1. ใช้ Descriptการตั้งชื่อ: ตั้งชื่อการทดสอบโดยพิจารณาจากพฤติกรรม ไม่ใช่การใช้งาน
  2. การจัดกลุ่มเลเวอเรจ: สร้างกลุ่มทดสอบเชิงตรรกะ (Smoke, Regression)
  3. หลีกเลี่ยงการเขียนโค้ดแบบตายตัว: ใช้พารามิเตอร์หรือไฟล์คุณสมบัติสำหรับข้อมูลทดสอบ
  4. ลดการพึ่งพาให้น้อยที่สุด: ควรแยกกรณีทดสอบออกจากกันทุกครั้งที่ทำได้
  5. การกำหนดค่าส่วนกลาง: ใช้ testng.xml สำหรับการจัดเตรียมห้องสวีท
  6. บูรณาการการรายงาน: ใช้โปรแกรมฟังเสียงหรือเครื่องมือจากภายนอก เช่น ExtentReports
  7. ควรใช้ตรรกะการลองใหม่ด้วยความระมัดระวัง: หลีกเลี่ยงการปกปิดข้อบกพร่องที่แท้จริง

การปฏิบัติตามสิ่งเหล่านี้จะช่วยให้มั่นใจได้ว่า ความสามารถในการปรับขนาด ความสามารถในการบำรุงรักษา และความอ่านง่าย ในระบบอัตโนมัติระดับองค์กร

28) @BeforeTest และ @BeforeSuite แตกต่างกันอย่างไร TestNG?

ลักษณะ @BeforeTest @BeforeSuite
ขอบเขต วิ่งก่อนแต่ละครั้ง <test> แท็กใน XML รันหนึ่งครั้งก่อนเริ่มใช้งานชุดโปรแกรมทั้งหมด
เวลา หลายครั้ง (ถ้ามีหลายครั้ง) <test> บล็อก) อนุญาตเพียงครั้งเดียวต่อห้องสวีท
การใช้งานทั่วไป เริ่มต้นการกำหนดค่าระดับการทดสอบ จัดตั้งทรัพยากรระดับโลก

ตัวอย่าง:

@BeforeSuite
public void setupSuite() {
    System.out.println("Global setup for suite.");
}

@BeforeTest
public void setupTest() {
    System.out.println("Setup for each <test> tag.");
}

ใช้ @BeforeSuite สำหรับ การกำหนดค่าทั่วโลก (เช่น การเชื่อมต่อฐานข้อมูล) และ @BeforeTest สำหรับ การเริ่มต้นเฉพาะการทดสอบ.

29) สามารถ TestNG สามารถนำไปใช้ในการทดสอบ API ได้อย่างไร? อย่างไร?

ใช่. TestNG สามารถนำไปใช้ได้อย่างมีประสิทธิภาพสำหรับ การทดสอบ API โดยการผสานรวมกับไลบรารีไคลเอ็นต์ HTTP เช่น มั่นใจได้เลย or ไคลเอนต์ HTTP.

ตัวอย่าง:

@Test
public void verifyApiResponse() {
    Response response = RestAssured.get("https://api.example.com/users");
    Assert.assertEquals(response.getStatusCode(), 200);
}

ข้อดี:

  • ช่วยให้ การตรวจสอบความถูกต้องตามการยืนยัน ของคำตอบ
  • รองรับ การกำหนดพารามิเตอร์ และ การทดสอบที่ขับเคลื่อนด้วยข้อมูล สำหรับจุดสิ้นสุดหลายจุด
  • สร้าง รายงานที่มีโครงสร้าง สำหรับการตรวจสอบความถูกต้องของ REST API

โดยการรวม TestNG และด้วย RestAssured ผู้ทดสอบสามารถรักษากรอบการทำงานอัตโนมัติที่เป็นหนึ่งเดียวสำหรับการทดสอบทั้ง UI และ API ได้

30) คุณส่งพารามิเตอร์จากบรรทัดคำสั่งในโปรแกรมอย่างไร TestNG?

คุณสามารถแทนที่พารามิเตอร์ XML ในขณะรันไทม์ได้โดยการส่งคุณสมบัติของระบบโดยใช้ -D ธง.

ตัวอย่างคำสั่ง:

mvn test -Dbrowser=chrome -Denv=staging

ตัวอย่างรหัส:

@Parameters("browser")
@Test
public void launch(@Optional("firefox") String browser) {
    System.out.println("Running on: " + browser);
}

สิ่งนี้ทำให้ การเลือกสภาพแวดล้อมแบบไดนามิก ในไปป์ไลน์ CI/CD โดยไม่ต้องแก้ไขไฟล์การกำหนดค่า ช่วยเพิ่มความยืดหยุ่นในการทดสอบ

31) คุณจะควบคุมลำดับการดำเนินการทดสอบได้อย่างไร TestNG โดยไม่ใช้ลำดับความสำคัญใช่ไหม?

แทนที่จะใช้ priority, TestNG ช่วยให้สามารถควบคุมผ่านทาง การอ้างอิง และ การเรียงลำดับวิธีการ XML.

วิธีการ:

  1. การใช้ dependsOnMethods:
    2. @Test
public void login() { ... }

@Test(dependsOnMethods = "login")
public void verifyDashboard() { ... }
  2. การใช้ลำดับวิธี XML:
    3. <classes>
  <class name="com.test.LoginTests">
    <methods>
      <include name="login"/>
      <include name="verifyDashboard"/>
    </methods>
  </class>
</classes>

ปฏิบัติที่ดีที่สุด: สำหรับกระบวนการทำงานที่ซับซ้อน ควรพิจารณาความสัมพันธ์เชิงตรรกะแทนลำดับความสำคัญแบบคงที่ เพื่อให้มั่นใจได้ว่าชุดทดสอบมีความแข็งแกร่งและบำรุงรักษาได้ง่าย

32) คุณสามารถเรียกใช้เมธอดทดสอบเฉพาะจากบรรทัดคำสั่งได้อย่างไร TestNG?

TestNG ช่วยให้ การดำเนินการทดสอบระดับเมธอด เรียกใช้โดยตรงจากบรรทัดคำสั่งโดยใช้ไฟล์ XML หรือการกำหนดค่า Maven Surefire

ตัวเลือกที่ 1: การใช้ไฟล์ XML

<class name="com.test.LoginTests">
  <methods>
    <include name="verifyLogin"/>
  </methods>
</class>

ตัวเลือกที่ 2: คำสั่ง Maven

mvn test -Dtest=com.test.LoginTests#verifyLogin

วิธีนี้ช่วยให้ การดำเนินการแบบเลือกสรรมีประโยชน์สำหรับการดีบักเมธอดแต่ละรายการ หรือตรวจสอบความถูกต้องของฟังก์ชันการทำงานที่สำคัญระหว่างการสร้างอย่างรวดเร็ว

33) คุณจะกำหนดพารามิเตอร์สำหรับการทดสอบโดยใช้ไฟล์ Excel ภายนอกได้อย่างไร TestNG?

การกำหนดค่าพารามิเตอร์โดยใช้ Excel เป็นเรื่องปกติในเฟรมเวิร์กที่ขับเคลื่อนด้วยข้อมูล ซึ่งข้อมูลทดสอบมีการเปลี่ยนแปลงบ่อยครั้ง

ขั้นตอนการดำเนินการ:

  1. ใช้ อาปาเช่ POI or เจเอ็กซ์เซล เพื่ออ่านข้อมูลจากไฟล์ Excel
  2. ป้อนเข้าไปใน @DataProvider วิธี

ตัวอย่าง:

@DataProvider(name = "excelData")
public Object[][] readExcel() throws Exception {
    FileInputStream fis = new FileInputStream("data.xlsx");
    XSSFWorkbook wb = new XSSFWorkbook(fis);
    XSSFSheet sheet = wb.getSheetAt(0);
    Object[][] data = new Object[sheet.getLastRowNum()][2];
    for (int i = 0; i < sheet.getLastRowNum(); i++) {
        data[i][0] = sheet.getRow(i + 1).getCell(0).getStringCellValue();
        data[i][1] = sheet.getRow(i + 1).getCell(1).getStringCellValue();
    }
    return data;
}

วิธีนี้ช่วยให้สามารถใช้ระเบียบวิธีทดสอบเดียวกันกับชุดข้อมูลจริงหลายชุดจาก Excel ซึ่งเพิ่มความยืดหยุ่นและความครอบคลุมมากขึ้น

34) คุณจะวิ่งได้อย่างไร TestNG ทดสอบใน Jenkins หรือในไปป์ไลน์ CI/CD?

TestNG รวมเข้ากับ เจนกิ้นส์, GitLab CIหรือ การกระทำของ GitHub ผ่านทาง Maven หรือ Gradle สร้าง

ขั้นตอนการใช้งาน Jenkins:

  1. การติดตั้ง ปลั๊กอินการรวม Maven.
  2. สร้าง งานฟรีสไตล์หรืองานวางท่อ.
  3. เพิ่ม mvn clean test เป็นขั้นตอนการสร้าง
  4. หลังจากสร้างเสร็จแล้ว ให้กำหนดค่ารายงาน HTML:
    • รายชื่อรายงาน: test-output
    • ไฟล์ดัชนี: index.html

ประโยชน์ที่ได้รับ:

  • ช่วยให้สามารถทดสอบการถดถอยแบบอัตโนมัติได้
  • 提供การทดสอบตามกำหนดเวลาและการติดตามแนวโน้ม
  • ช่วยให้การทดสอบดำเนินการอย่างสม่ำเสมอในทุกสภาพแวดล้อม

35) วัตถุประสงค์ของ @Parameters คืออะไร และแตกต่างจาก @Optional อย่างไร?

คำอธิบายทั้งสองเกี่ยวข้องกับการกำหนดพารามิเตอร์ แต่มีจุดประสงค์ที่แตกต่างกัน

ลักษณะ @Parameters @Optional
จุดมุ่งหมาย ส่งผ่านพารามิเตอร์จากไฟล์ XML กำหนดค่าเริ่มต้นหากไม่มีการระบุพารามิเตอร์
การประกาศ ใช้ร่วมกับ XML <parameter> ใช้ภายในวิธีการทดสอบ
พฤติกรรม จะแสดงข้อผิดพลาดหากค่าหายไป ใช้ค่าสำรอง

ตัวอย่าง:

@Test
@Parameters("browser")
public void runTest(@Optional("chrome") String browser) {
    System.out.println("Running on: " + browser);
}

การใช้ @Optional เพื่อให้แน่ใจ ทดสอบความเสถียร เมื่อการตั้งค่า XML ไม่สมบูรณ์

36) คุณจัดการกับความสัมพันธ์ของการทดสอบระหว่างคลาสต่างๆ อย่างไร TestNG?

เพื่อสร้างความสัมพันธ์ระหว่างคลาสต่างๆ TestNG อนุญาตให้ใช้ dependsOnGroups คุณลักษณะ

ตัวอย่าง:

@Test(groups = "Login")
public void loginTest() { ... }

@Test(groups = "Dashboard", dependsOnGroups = "Login")
public void dashboardTest() { ... }

แนวทางนี้ช่วยในการจัดการ การพึ่งพาโมดูลหลายตัว โดยแต่ละคลาสจะแทนโมดูล (เช่น การเข้าสู่ระบบ แดชบอร์ด การชำระเงิน เป็นต้น)

วิธีนี้จะช่วยให้มั่นใจได้ว่าโมดูลที่เกี่ยวข้องจะทำงานก็ต่อเมื่อการทดสอบเงื่อนไขเบื้องต้นสำเร็จเท่านั้น ซึ่งจะช่วยรักษาความสมบูรณ์ของการทดสอบไว้ได้

37) ความล้มเหลวในการกำหนดค่าคืออะไรใน TestNGและเราจะจัดการกับปัญหาเหล่านี้ได้อย่างไร?

การกำหนดค่าจะล้มเหลวเมื่อวิธีการตั้งค่าหรือยกเลิกการตั้งค่ามีคำอธิบายประกอบด้วย @Before* or @After* ล้มเหลว.

พวกเขาสามารถทำให้เกิด การทดสอบที่เกี่ยวข้องที่จะข้ามแม้ว่าผลการทดสอบเหล่านั้นจะถูกต้องก็ตาม

สาเหตุทั่วไป:

  • การเริ่มต้นใช้งาน WebDriver ไม่ถูกต้อง
  • ปัญหาเกี่ยวกับการตั้งค่าฐานข้อมูลหรือสภาพแวดล้อม
  • การตั้งค่าพารามิเตอร์ไม่ถูกต้อง

แนวทางแก้ไขปัญหา :

  • ใช้ ลองจับ บล็อกในวิธีการตั้งค่า
  • สมัครสมาชิก alwaysRun = true เพื่อให้มั่นใจว่าการทำความสะอาดจะดำเนินต่อไปได้แม้จะเกิดข้อผิดพลาดก็ตาม

ตัวอย่าง:

@BeforeMethod(alwaysRun = true)
public void setup() {
    // Setup logic
}

วิธีนี้จะช่วยให้มั่นใจได้ว่าวิธีการยกเลิกการใช้งานของคุณยังคงทำงานได้ ซึ่งจะช่วยรักษาเสถียรภาพของสภาพแวดล้อมการทดสอบ

38) คุณสมบัติ invocationCount และ threadPoolSize มีประโยชน์อย่างไรใน TestNG?

คุณสมบัติเหล่านี้ช่วยให้ การดำเนินการทดสอบซ้ำและแบบขนาน โดยใช้วิธีการเดียวกัน

ตัวอย่าง:

@Test(invocationCount = 5, threadPoolSize = 2)
public void loadTest() {
    System.out.println("Running load test...");
}
คุณลักษณะ Descriptไอออน
invocationCount จำนวนครั้งที่เมธอดทำงาน
threadPoolSize จำนวนเธรดที่ทำงานพร้อมกัน

ใช้กรณี: การทดสอบประสิทธิภาพ การตรวจสอบความเสถียร หรือการจำลองพฤติกรรมที่ผิดปกติในการทำงานหลายครั้ง

39) คุณจะรันเฉพาะกรณีทดสอบที่ล้มเหลวได้อย่างไร TestNG?

หลังจากวิ่งในห้องสวีทเสร็จแล้ว TestNG สร้างไฟล์ชื่อ... testng-failed.xml ที่ test-output ไดเรกทอรี

คุณสามารถเรียกใช้การทดสอบที่ล้มเหลวซ้ำได้โดยการเรียกใช้คำสั่ง:

java -cp testng.jar org.testng.TestNG test-output/testng-failed.xml

ข้อดี:

  • ช่วยประหยัดเวลาด้วยการข้ามการทดสอบที่สำเร็จแล้ว
  • ช่วยให้การแก้ไขข้อผิดพลาดในชุดทดสอบขนาดใหญ่ทำได้ง่ายขึ้น
  • นิยมใช้ในกระบวนการ CI (Continuous Integration) เพื่อการทดสอบซ้ำอย่างรวดเร็ว

นอกจากนี้ คุณยังสามารถผสานรวมสิ่งนี้เข้ากับ Jenkins โดยใช้สคริปต์หลังการสร้างเพื่อเรียกใช้งานซ้ำได้

40) ข้อจำกัดบางประการของมีอะไรบ้าง TestNG แล้วจะบรรเทาได้อย่างไร?

ถึงแม้จะมีความทนทานสูงก็ตาม TestNG มีข้อจำกัดอยู่บ้าง

การ จำกัด กลยุทธ์การบรรเทาผลกระทบ
ความซับซ้อนของการกำหนดค่า XML ใช้การกำหนดค่าและการสร้างตามคำอธิบายประกอบ
การรายงานพื้นเมืองที่จำกัด ผสานรวม ExtentReports หรือ Allure เข้าด้วยกัน
ไม่มีระบบควบคุมการลองใหม่ในตัว Implement IRetryAnalyzer
ข้อกังวลด้านความปลอดภัยของเธรดในการทำงานแบบขนาน ใช้ WebDriver instances ที่ทำงานเฉพาะเธรด
เส้นโค้งการเรียนรู้สำหรับผู้เริ่มต้น รักษาโครงสร้างโครงการตามเทมเพลต

ด้วยการออกแบบโครงสร้างที่เหมาะสมและแนวปฏิบัติที่ดีที่สุด ข้อจำกัดเหล่านี้สามารถลดลงได้ ทำให้มั่นใจได้ว่าโซลูชันระบบอัตโนมัติมีความเสถียรและบำรุงรักษาได้ง่าย

41) คุณใช้ Listener ในการบันทึกและจับภาพหน้าจออย่างไร Selenium-TestNG?

ผู้ฟังใน TestNG ช่วยตรวจสอบการดำเนินการทดสอบและดำเนินการต่างๆ เช่น การบันทึกข้อมูล การจับภาพหน้าจอ หรือการรายงานผลลัพธ์แบบไดนามิก

ตัวอย่างการใช้งาน:

public class ScreenshotListener implements ITestListener {
  @Override
  public void onTestFailure(ITestResult result) {
      WebDriver driver = ((BaseTest) result.getInstance()).getDriver();
      File src = ((TakesScreenshot) driver).getScreenshotAs(OutputType.FILE);
      FileUtils.copyFile(src, new File("screenshots/" + result.getName() + ".png"));
  }
}

การใช้งาน:

@Listeners(ScreenshotListener.class)
public class LoginTests extends BaseTest { ... }

ประโยชน์ที่ได้รับ:

  • ตรวจจับข้อผิดพลาดโดยอัตโนมัติ
  • ช่วยให้การแก้ไขข้อผิดพลาดมีประสิทธิภาพมากขึ้นด้วยหลักฐานเชิงภาพ
  • ช่วยลดภาระงานในการบันทึกข้อมูลด้วยตนเอง

เทคนิคนี้มีความสำคัญอย่างยิ่งในกระบวนการทำงานอัตโนมัติของ CI/CD โดยเฉพาะอย่างยิ่งในการวินิจฉัยความล้มเหลวของบิลด์จากระยะไกล

42) IReporter และ ITestListener แตกต่างกันอย่างไร TestNG?

ลักษณะ IReporter ITestListener
จุดมุ่งหมาย สร้างรายงานแบบกำหนดเองหลังจากการทดสอบเสร็จสิ้น ติดตามและตอบสนองต่อเหตุการณ์การทดสอบขณะรันไทม์
การภาวนา หลังจากทำการทดสอบทั้งหมดเสร็จสิ้นแล้ว ในระหว่างวงจรการทดสอบ (เริ่มต้น สำเร็จ ล้มเหลว)
เอาท์พุต รายงาน HTML/XML/JSON ไฟล์บันทึก, ภาพหน้าจอ, แดชบอร์ดแบบเรียลไทม์
การใช้งานทั่วไป การผสานรวม ExtentReports และ Allure การบันทึกข้อมูล การจัดการข้อผิดพลาด กลไกการลองใหม่

ตัวอย่าง:

  • ใช้ IReporter สำหรับอาคาร รายงานที่ครอบคลุม หลังจากการทดสอบเสร็จสิ้น
  • ใช้ ITestListener สำหรับ การบันทึกข้อมูลแบบเรียลไทม์หรือภาพหน้าจอ.

พวกเขายังสามารถ รวม เพื่อสร้างระบบวิเคราะห์อัตโนมัติแบบครบวงจร

43) คุณทำการทดสอบข้ามเบราว์เซอร์โดยใช้วิธีใด TestNG การกำหนดค่า XML?

การทดสอบข้ามเบราว์เซอร์ช่วยให้มั่นใจได้ว่าฟังก์ชันการทำงานเดียวกันนั้นใช้งานได้ในเบราว์เซอร์ต่างๆ

การกำหนดค่าตัวอย่าง:

<suite name="CrossBrowserSuite" parallel="tests">
  <test name="ChromeTest">
    <parameter name="browser" value="chrome"/>
    <classes><class name="com.test.LoginTest"/></classes>
  </test>
  <test name="FirefoxTest">
    <parameter name="browser" value="firefox"/>
    <classes><class name="com.test.LoginTest"/></classes>
  </test>
</suite>

Java รหัส:

@Parameters("browser")
@BeforeClass
public void setup(String browser) {
    if(browser.equalsIgnoreCase("chrome"))
        driver = new ChromeDriver();
    else if(browser.equalsIgnoreCase("firefox"))
        driver = new FirefoxDriver();
}

แนวทางนี้ช่วยให้ การประมวลผลแบบขนานในหลายเบราว์เซอร์ช่วยเร่งการครอบคลุมการทดสอบในทุกแพลตฟอร์ม

44) คุณบูรณาการอย่างไร TestNG ด้วย Docker หรือ Selenium กริด?

TestNG รวมเข้ากับ ด็อกเกอร์ Selenium ตะแกรง เพื่อเปิดใช้งานการทดสอบแบบขนานแบบกระจาย

ขั้นตอน:

  1. จัดตั้งขึ้น Selenium กริดใน Docker ใช้อย่างเป็นทางการ Selenium ภาพ: 
    docker run -d -p 4444:4444 --name selenium-grid selenium/standalone-chrome
  2. บันทึก TestNG ติดตั้ง:
    3. DesiredCapabilities caps = new DesiredCapabilities();
caps.setBrowserName("chrome");
driver = new RemoteWebDriver(new URL("http://localhost:4444/wd/hub"), caps);
  3. เรียกใช้ชุดทดสอบของคุณผ่าน Jenkins หรือ CI pipeline

ประโยชน์ที่ได้รับ:

  • ช่วยให้ การทดสอบแบบขนานที่ปรับขนาดได้.
  • ลดภาระในการตั้งค่าสภาพแวดล้อม
  • ให้ การดำเนินการทดสอบอย่างสม่ำเสมอ ในคอนเทนเนอร์แบบกระจาย

45) ความแตกต่างระหว่างการประมวลผลแบบขนานในระดับชุดทดสอบ ระดับการทดสอบ และระดับเมธอดคืออะไร TestNG?

ชั้น คุณลักษณะคู่ขนาน พฤติกรรมการดำเนินการ
ชุด parallel="suites" ดำเนินการชุดทดสอบหลายชุดพร้อมกัน
เอกสาร parallel="tests" วิ่ง <test> บล็อกพร้อมกัน
ชั้น parallel="classes" รันคลาสทดสอบแบบขนาน
วิธี parallel="methods" ดำเนินการวิธีการทดสอบแต่ละวิธีแบบขนานกัน

ตัวอย่าง:

<suite name="ParallelTests" parallel="methods" thread-count="3">
  <test name="SampleTest">
    <classes><class name="com.test.ParallelExample"/></classes>
  </test>
</suite>

ปฏิบัติที่ดีที่สุด:ใช้ parallel="classes" เพื่อความเสถียรใน Selenium ทดสอบเพื่อหลีกเลี่ยงความขัดแย้งของไดรเวอร์ที่ใช้ร่วมกัน

46) คุณจะสามารถแชร์ข้อมูลระหว่างการทดสอบโดยไม่ต้องใช้ตัวแปรส่วนกลางได้อย่างไร TestNG?

TestNG ให้ ITestContext และ การฉีดพึ่งพา เพื่อแบ่งปันข้อมูลแบบไดนามิก

ตัวอย่าง:

@Test
public void storeData(ITestContext context) {
    context.setAttribute("token", "abc123");
}

@Test(dependsOnMethods = "storeData")
public void useData(ITestContext context) {
    String token = (String) context.getAttribute("token");
    System.out.println("Using token: " + token);
}

วิธีนี้ช่วยหลีกเลี่ยงการใช้ตัวแปรคงที่ รักษาความปลอดภัยของเธรด และรับประกันได้ว่า การแยกข้อมูลระหว่างการทดสอบ.

47) คุณจะบันทึกและจัดเก็บการทดสอบที่ถูกข้ามไปได้อย่างไร TestNG?

คุณสามารถบันทึกการทดสอบที่ถูกข้ามไปได้โดยใช้ onTestSkipped() ที่ ITestListener อินเตอร์เฟซ.

ตัวอย่าง:

@Override
public void onTestSkipped(ITestResult result) {
    System.out.println("Skipped Test: " + result.getName());
}

เหตุผลที่ควรข้าม:

  • การทดสอบล้มเหลวเนื่องจากเงื่อนไขที่เกี่ยวข้อง
  • การข้ามแบบมีเงื่อนไขผ่าน SkipException.
  • สภาพแวดล้อมไม่พร้อมใช้งาน

ปฏิบัติที่ดีที่สุด:
บันทึกเหตุผลการข้ามและร่องรอยการทำงานเพื่อการตรวจสอบย้อนกลับในรายงาน CI หรือแดชบอร์ด

48) อธิบายวิธีการกำหนดพารามิเตอร์สำหรับการทดสอบ REST API โดยใช้ TestNG และวางใจได้เลย

TestNG's @DataProvider ผสานรวมได้อย่างลงตัวกับ มั่นใจได้เลย สำหรับการกำหนดค่าพารามิเตอร์ของ API

ตัวอย่าง:

@DataProvider(name = "apiData")
public Object[][] apiData() {
  return new Object[][] {
    {"https://api.example.com/users/1"},
    {"https://api.example.com/users/2"}
  };
}

@Test(dataProvider = "apiData")
public void testApi(String url) {
  Response response = RestAssured.get(url);
  Assert.assertEquals(response.getStatusCode(), 200);
}

ข้อดี:

  • เรียกใช้ API เดียวกันสำหรับปลายทางหรือเพย์โหลดหลายรายการ
  • ช่วยลดความซับซ้อนของการทดสอบการถดถอยสำหรับ API ที่มีชุดข้อมูลอินพุตที่หลากหลาย
  • ผสานการทำงานเข้ากับเครื่องมือและรายงาน CI ได้อย่างราบรื่น

49) คุณจะสร้างคำอธิบายประกอบแบบกำหนดเองได้อย่างไร TestNG สำหรับรูปแบบการทดสอบที่นำกลับมาใช้ใหม่ได้?

การใส่คำอธิบายประกอบแบบกำหนดเองสามารถช่วยสร้างมาตรฐานให้กับการตั้งค่าการทดสอบหรือการตรวจสอบความถูกต้องที่ซ้ำซากได้

ตัวอย่าง:

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface SmokeTest {
  String description() default "Smoke Test";
}

การใช้งาน:

@SmokeTest(description="Validating Login Functionality")
@Test
public void loginTest() { ... }

เมื่อผนวกรวมกับการสะท้อน (reflection) คุณจะสามารถอ่านคำอธิบายประกอบเหล่านี้แบบไดนามิกเพื่อจัดกลุ่มการทดสอบหรือควบคุมการทำงานแบบมีเงื่อนไขได้

เทคนิคนี้ถูกนำมาใช้อย่างแพร่หลายใน การเขียนโปรแกรมเมตาของเฟรมเวิร์ก เพื่อสร้างชุดทดสอบที่มีคำอธิบายในตัว

50) คุณสามารถผสมผสานได้อย่างไร Cucumber และ TestNG สำหรับเฟรมเวิร์กการทดสอบแบบไฮบริด?

TestNG สามารถทำหน้าที่เป็น นักวิ่งทดสอบ สำหรับ Cucumber สถานการณ์จำลอง BDD ที่ให้การรายงานที่มีประสิทธิภาพและการประมวลผลแบบขนาน

ตัวอย่างนักวิ่ง:

@CucumberOptions(
  features = "src/test/resources/features",
  glue = "stepDefinitions",
  plugin = {"pretty", "html:target/cucumber-report.html"}
)
public class RunCucumberTest extends AbstractTestNGCucumberTests { }

ข้อดี:

  • ยกระดับ TestNG's คำอธิบายประกอบ ผู้ฟัง และการรายงาน.
  • รองรับ การประมวลผลคุณลักษณะแบบขนาน.
  • ผสานรวมกับ จูงใจ และ รายงานขอบเขต อย่างง่ายดาย

แนวทางแบบผสมผสานนี้เป็นการผสานรวม ความสามารถในการอ่าน BDD สีสดสวย TestNG ความยืดหยุ่นเหมาะอย่างยิ่งสำหรับเฟรมเวิร์กระดับองค์กร

🔍 ด้านบน TestNG คำถามสัมภาษณ์พร้อมสถานการณ์จริงและคำตอบเชิงกลยุทธ์

ด้านล่างนี้คือ 10 ตัวอย่างที่สมจริงและเกี่ยวข้องกับสาขาที่เกี่ยวข้อง TestNG คำถามสัมภาษณ์พร้อมความคาดหวังที่ชัดเจนและตัวอย่างคำตอบที่ดี

1) คุณช่วยอธิบายข้อดีที่สำคัญของการใช้ได้ไหม TestNG เปรียบเทียบกับ JUnit?

สิ่งที่คาดหวังจากผู้สมัคร: แสดงให้เห็นถึงความเข้าใจในเรื่อง TestNGคุณสมบัติที่ได้รับการปรับปรุง และเหตุผลที่มักถูกเลือกใช้สำหรับการทำงานอัตโนมัติในระดับองค์กร

ตัวอย่างคำตอบ: "TestNG มีข้อดีหลายประการ เช่น การกำหนดค่าการทดสอบที่ยืดหยุ่น การสนับสนุนการทำงานแบบขนาน วิธีการทดสอบแบบพึ่งพา การทดสอบที่ขับเคลื่อนด้วยข้อมูลโดยใช้ DataProviders และการรายงานในตัว ความสามารถเหล่านี้ทำให้ TestNG มีประสิทธิภาพมากขึ้นสำหรับเฟรมเวิร์กการทำงานอัตโนมัติที่ซับซ้อนซึ่งต้องการความสามารถในการปรับขนาด”

2) คุณใช้อย่างไร TestNG การใช้คำอธิบายประกอบเพื่อควบคุมลำดับการทำงานของการทดสอบ?

สิ่งที่คาดหวังจากผู้สมัคร: มีความรู้เกี่ยวกับวัตถุประสงค์และลำดับของการใส่คำอธิบายประกอบ

ตัวอย่างคำตอบ: "TestNG มีคำอธิบายประกอบต่างๆ เช่น @BeforeSuite, @BeforeClass, @BeforeMethod, @Test และคำอธิบายประกอบสำหรับการยกเลิกการตั้งค่าที่เกี่ยวข้อง สิ่งเหล่านี้ช่วยให้สามารถจัดระเบียบการตั้งค่าและการทำความสะอาดการทดสอบได้อย่างเป็นระบบ ตัวอย่างเช่น @BeforeMethod จะทำงานก่อนเมธอดทดสอบแต่ละตัว ซึ่งมีประโยชน์สำหรับการเริ่มต้นสถานะของเบราว์เซอร์”

3) อธิบายโครงการระบบอัตโนมัติที่ท้าทายโครงการหนึ่งๆ โดยที่ TestNG มีบทบาทสำคัญ

สิ่งที่คาดหวังจากผู้สมัคร: ประสบการณ์การทำงานในโครงการจริงและความสามารถในการอธิบายวิธีการแก้ปัญหา

ตัวอย่างคำตอบ: “ในบทบาทก่อนหน้านี้ ผมทำงานในโครงการที่ต้องมีการทดสอบการถดถอยอย่างครอบคลุมในสภาพแวดล้อมที่หลากหลาย” TestNGคุณสมบัติการประมวลผลแบบขนานและการจัดกลุ่ม ช่วยให้ทีมสามารถเรียกใช้ชุดทดสอบที่สำคัญพร้อมกันได้ ลดเวลาในการประมวลผลลงอย่างมาก ในขณะที่ยังคงรักษาความน่าเชื่อถือไว้ได้”

4) ทำอย่างไร TestNG การทำงานเป็นกลุ่มช่วยในการจัดระเบียบและดำเนินการทดสอบได้อย่างมีประสิทธิภาพหรือไม่?

สิ่งที่คาดหวังจากผู้สมัคร: ความเข้าใจเกี่ยวกับการจัดกลุ่ม รวมถึงกลไกการรวม/การแยกออก

ตัวอย่างคำตอบ: “กลุ่มใน TestNG อนุญาตให้จัดหมวดหมู่กรณีทดสอบ เช่น การทดสอบเบื้องต้น (smoke test), การทดสอบการถดถอย (regression test) และการทดสอบการบูรณาการ (integration test) โดยใช้ testng.xml ฉันสามารถเลือกเรียกใช้กลุ่มทดสอบ ยกเว้นการทดสอบที่ไม่เสถียร และจัดการชุดทดสอบต่างๆ ได้โดยไม่ต้องแก้ไขโค้ดเอง”

5) อธิบายสถานการณ์ที่คุณต้องแก้ไขข้อผิดพลาดที่เกิดขึ้น TestNG การทดสอบ คุณใช้วิธีการอย่างไร?

สิ่งที่คาดหวังจากผู้สมัคร: ทักษะการคิดวิเคราะห์และการแก้ไขปัญหา

ตัวอย่างคำตอบ: “ในตำแหน่งงานก่อนหน้านี้ ผมได้พบกับความล้มเหลวหลายประการ” TestNG การทดสอบที่ดูเหมือนจะผ่านในเครื่อง แต่ล้มเหลวใน CI ผมจึงเปิดใช้งานการบันทึกข้อมูลโดยละเอียด ตรวจสอบลำดับการดำเนินการ และพบว่าทรัพยากรที่ใช้ร่วมกันไม่ได้ถูกรีเซ็ตระหว่างการทดสอบ จากนั้นผมจึงใช้ขั้นตอนการยกเลิกการใช้งานที่เหมาะสมโดยใช้ @AfterMethod เพื่อให้แน่ใจว่าการทดสอบแยกออกจากกัน”

6) คุณนำการทดสอบที่ขับเคลื่อนด้วยข้อมูลไปใช้อย่างไร TestNG?

สิ่งที่คาดหวังจากผู้สมัคร: ความเข้าใจเกี่ยวกับผู้ให้บริการข้อมูลและกรณีการใช้งาน

ตัวอย่างคำตอบ: “ฉันสร้างเมธอด @DataProvider ที่ส่งคืนข้อมูลในรูปแบบอาร์เรย์ของอ็อบเจ็กต์ จากนั้นจึงผูกเมธอดนั้นเข้ากับเมธอด @Test โดยใช้แอตทริบิวต์ dataProvider วิธีนี้ช่วยให้สามารถทดสอบซ้ำได้หลายครั้งด้วยชุดข้อมูลอินพุตที่แตกต่างกัน ซึ่งมีประโยชน์สำหรับการตรวจสอบความถูกต้องของการส่งแบบฟอร์มหรือความหลากหลายของข้อมูลที่ส่งผ่าน API”

7) คุณจัดการการพึ่งพาของการทดสอบอย่างไรใน TestNG?

สิ่งที่คาดหวังจากผู้สมัคร: การใช้งาน dependsOnMethods หรือ dependsOnGroups อย่างถูกต้อง

ตัวอย่างคำตอบ: "TestNG อนุญาตให้กำหนดความสัมพันธ์ระหว่างการทดสอบผ่านแอตทริบิวต์ dependsOnMethods และ dependsOnGroups ฉันใช้ความสัมพันธ์เหล่านี้เมื่อการทดสอบหนึ่งต้องทำงานหลังจากที่การทดสอบอื่นเสร็จสมบูรณ์แล้วเท่านั้น เช่น การตรวจสอบคำสั่งซื้อหลังจากสร้างคำสั่งซื้อเสร็จแล้วเท่านั้น”

8) อธิบายว่าคุณได้ใช้อย่างไร TestNG ด้วยเครื่องมือการบูรณาการอย่างต่อเนื่อง

สิ่งที่คาดหวังจากผู้สมัคร: ประสบการณ์จริงในการสร้างระบบอัตโนมัติแบบต่อเนื่อง

ตัวอย่างคำตอบ: “ในงานก่อนหน้านี้ ฉันทำหน้าที่บูรณาการ” TestNG โดยใช้ Jenkins โดยการกำหนดค่าการสร้าง Maven เพื่อสร้าง TestNG รายงานในรูปแบบ HTML และ XML จากนั้น Jenkins จะจัดเก็บรายงานเหล่านั้นและแสดงผลลัพธ์หลังจากรอบการสร้างแต่ละครั้ง การผสานรวมนี้ช่วยให้ทีมติดตามความล้มเหลวได้อย่างรวดเร็วและรักษาเสถียรภาพของการปล่อยเวอร์ชันใหม่”

9) เล่าให้ฟังหน่อยว่ามีครั้งไหนที่คุณต้องทำงานภายใต้กำหนดเวลาที่กระชั้นชิดพร้อมๆ กับจัดการงานอัตโนมัติหลายอย่างพร้อมกัน

สิ่งที่คาดหวังจากผู้สมัคร: การบริหารเวลาและความสามารถในการจัดลำดับความสำคัญ

ตัวอย่างคำตอบ: “ในบทบาทล่าสุดของฉัน ฉันจำเป็นต้องอัปเดตข้อมูลที่มีอยู่แล้ว” TestNG ฉันสร้างชุดทดสอบใหม่พร้อมทั้งสร้างชุดทดสอบใหม่สำหรับเวอร์ชันที่จะออกในอนาคต ฉันจัดลำดับความสำคัญของงานตามผลกระทบทางธุรกิจ เริ่มทำการทดสอบอัตโนมัติในส่วนที่มีความเสี่ยงสูงสุดก่อน และใช้ TestNG โดยจัดกลุ่มเพื่อแยกส่วนที่เสร็จสมบูรณ์แล้วสำหรับการตรวจสอบเบื้องต้น ซึ่งช่วยให้ส่งมอบงานได้ทันเวลาโดยไม่ลดทอนคุณภาพ”

10) คุณจะออกแบบระบบที่ปรับขนาดได้อย่างไร TestNG เป็นกรอบการทำงานสำหรับแอปพลิเคชันขนาดใหญ่หรือไม่?

สิ่งที่คาดหวังจากผู้สมัคร: Archiความเข้าใจด้านสถาปัตยกรรม รูปแบบ และแนวปฏิบัติที่ดีที่สุด

ตัวอย่างคำตอบ: “ผมจะออกแบบเฟรมเวิร์กแบบโมดูลาร์โดยใช้ Page Object Model และบูรณาการเข้าด้วยกัน” TestNG สำหรับการจัดการการดำเนินการ และใช้ DataProviders สำหรับสถานการณ์ที่ขับเคลื่อนด้วยข้อมูล นอกจากนี้ ผมจะกำหนดค่าการดำเนินการแบบขนาน รวมศูนย์ยูทิลิตี้ และแยกการตั้งค่าการกำหนดค่าออกเป็นส่วนภายนอก เพื่อให้เฟรมเวิร์กยังคงปรับขนาดได้และบำรุงรักษาได้ง่ายเมื่อแอปพลิเคชันเติบโตขึ้น”

สรุปโพสต์นี้ด้วย: