JUnit vs TestNG [ปิด]

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

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

ฉันเคยใช้ทั้งสองอย่าง แต่ฉันต้องยอมรับกับ Justin Standard ว่าคุณไม่ควรพิจารณาเขียนการทดสอบที่มีอยู่ของคุณใหม่เป็นรูปแบบใหม่ ไม่ว่าการตัดสินใจจะเป็นเรื่องเล็กน้อยที่จะเรียกใช้ทั้งสองอย่าง TestNG มุ่งมั่นที่จะกำหนดค่าได้มากกว่า JUnit แต่ในที่สุดทั้งสองก็ทำงานได้ดีเท่ากัน

TestNG มีคุณสมบัติที่เป็นระเบียบซึ่งคุณสามารถทำเครื่องหมายการทดสอบเป็นกลุ่มเฉพาะจากนั้นเรียกใช้การทดสอบทั้งหมดของกลุ่มเฉพาะหรือยกเว้นการทดสอบของกลุ่มใดกลุ่มหนึ่งได้อย่างง่ายดาย ดังนั้นคุณสามารถทำเครื่องหมายการทดสอบที่ทำงานช้าในกลุ่ม "ช้า" แล้วเพิกเฉยเมื่อคุณต้องการผลลัพธ์ที่รวดเร็ว ข้อเสนอแนะจากเอกสารของพวกเขาคือการทำเครื่องหมายชุดย่อยบางรายการเป็นการทดสอบ "checkin" ซึ่งควรเรียกใช้เมื่อใดก็ตามที่คุณตรวจสอบไฟล์ใหม่ฉันไม่เคยเห็นคุณลักษณะนี้ใน JUnit แต่ถ้าคุณไม่มีคุณก็อย่า พลาดไม่ได้จริงๆ

สำหรับการอ้างสิทธิ์ทั้งหมดของการกำหนดค่าที่สูงฉันได้พบกับกรณีมุมเมื่อสองสามสัปดาห์ก่อนซึ่งฉันไม่สามารถทำในสิ่งที่ต้องการได้ ... ฉันหวังว่าฉันจะจำได้ว่ามันคืออะไร แต่ฉันต้องการนำมันขึ้นมา ดังนั้นคุณจะรู้ว่ามันไม่สมบูรณ์แบบ

ข้อได้เปรียบที่ใหญ่ที่สุดของ TestNG คือคำอธิบายประกอบ ... ซึ่ง JUnit ได้เพิ่มเข้ามาในเวอร์ชัน 4 อย่างไรก็ตาม

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

ใช้อะไรก็ได้ที่ดูเป็นธรรมชาติที่สุดและช่วยให้คุณทำงานสำเร็จ

ฉันไม่สามารถแสดงความคิดเห็นเกี่ยวกับ TestNG b / c ฉันไม่ได้ใช้ แต่ฉันอยากจะแนะนำunitilsซึ่งเป็นเครื่องห่อหุ้มที่ยอดเยี่ยมสำหรับ JUnit / TestNG / DBUnit / EasyMock ไม่ว่าคุณจะใช้เส้นทางใดก็ตาม (รองรับทุกรสชาติที่กล่าวมา)

การ์ดจั่วที่ใหญ่ที่สุดของ TestNG สำหรับฉันรวมถึงกลุ่มทดสอบที่สนับสนุนและที่สำคัญกว่านั้นคือการพึ่งพากลุ่มทดสอบ (การทำเครื่องหมายการทดสอบว่าขึ้นอยู่กับกลุ่มทำให้การทดสอบเพียงข้ามการทำงานเมื่อกลุ่มที่อ้างอิงล้มเหลว)

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

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

(ข้อจำกัดความรับผิดชอบ - ฉันไม่ได้ใช้ JUnit 4.x เลยดังนั้นฉันจึงไม่สามารถแสดงความคิดเห็นเกี่ยวกับความก้าวหน้าหรือคุณสมบัติใหม่ ๆ ได้)

ประมาณหนึ่งปีที่แล้วเรามีปัญหาเดียวกัน ฉันใช้เวลาพิจารณาว่าการเคลื่อนไหวใดดีกว่าและในที่สุดเราก็รู้ว่า TestNG ไม่มี 'คุณสมบัตินักฆ่า' เป็นสิ่งที่ดีและมีคุณสมบัติบางอย่างที่ JUnit 4 ไม่มี แต่เราไม่ต้องการ
เราไม่ต้องการให้ผู้คนรู้สึกอึดอัดในการเขียนแบบทดสอบในขณะที่ทำความรู้จักกับ TestNG เพราะเราต้องการให้พวกเขาเขียนแบบทดสอบต่อไปเรื่อย ๆ
นอกจากนี้ JUnit ยังเป็นมาตรฐาน de-facto ในโลก Java ไม่มีเครื่องมือที่ดีที่ไม่รองรับมันจากกล่องคุณสามารถค้นหาความช่วยเหลือมากมายบนเว็บและพวกเขาได้เพิ่มคุณสมบัติใหม่มากมายในปีที่ผ่านมาซึ่งแสดงให้เห็นว่ามันยังมีชีวิตอยู่

เราตัดสินใจที่จะติดกับ JUnit และไม่เคยมองย้อนกลับไป

ไชโยทั้งหมดข้างต้น สิ่งอื่น ๆ ที่ฉันพบโดยส่วนตัวแล้วฉันชอบมากกว่าใน TestNG ได้แก่ :

1. @BeforeClassสำหรับ TestNG จะเกิดขึ้นหลังจากการสร้างชั้นเรียนเพื่อให้คุณไม่ จำกัด โดยเฉพาะความสามารถในการเรียกวิธีการคงที่ของชั้นเรียนของคุณอยู่ในนั้น

2. การทดสอบแบบขนานและแบบกำหนดพารามิเตอร์บางทีฉันอาจมีชีวิตไม่พอ ... แต่ฉันเพิ่งได้รับการทดสอบการเขียนซีลีเนียมชุดเดียวโดยยอมรับชื่อไดรเวอร์เป็นพารามิเตอร์ จากนั้นกำหนดกลุ่มทดสอบแบบขนาน 3 กลุ่มกลุ่มละ 1 กลุ่มสำหรับไดรเวอร์ IE, FF และ Chrome แล้วดูการแข่งขัน! เดิมทีฉันทำ 4 แต่มีหน้าเว็บมากเกินไปที่ฉันใช้งานHtmlUnitไดร์เวอร์พังไม่ว่าจะด้วยเหตุผลใดก็ตาม

ใช่อาจจะต้องค้นหาชีวิตนั้น ;)

ฉันต้องการแบ่งปันสิ่งที่ฉันพบในวันนี้ ฉันพบว่า Parameterized runner ในตัวค่อนข้างหยาบใน Junit4 เมื่อเปรียบเทียบกับ TestNG (ฉันรู้ว่าแต่ละเฟรมเวิร์คมีจุดแข็ง แต่ก็ยัง) Junit4 annotation @parameters ถูก จำกัด ไว้ที่พารามิเตอร์ชุดเดียว ฉันพบปัญหานี้ขณะทดสอบพฤติกรรมที่ถูกต้องและไม่ถูกต้องสำหรับฟังก์ชันการทำงานในคลาสทดสอบเดียวกัน ดังนั้นจะใช้วิธีการใส่คำอธิบายประกอบแบบคงที่สาธารณะเป็นครั้งแรกที่พบ แต่อาจพบในลำดับใดก็ได้ สิ่งนี้ทำให้เราต้องเขียนคลาสต่างๆโดยไม่จำเป็น อย่างไรก็ตาม TestNG มีวิธีที่สะอาดในการจัดหาผู้ให้บริการข้อมูลประเภทต่างๆสำหรับแต่ละวิธี ดังนั้นเราจึงสามารถทดสอบหน่วยรหัสเดียวกันด้วยวิธีที่ถูกต้องและไม่ถูกต้องในคลาสทดสอบเดียวกันโดยแยกข้อมูลที่ถูกต้อง / ไม่ถูกต้องออกจากกัน ฉันจะไปกับ TestNG

ข้อดีอีกอย่างของ TestNG คือรองรับการทดสอบแบบขนาน ฉันคิดว่าในยุคของมัลติคอร์นั้นสำคัญ

ฉันยังใช้ทั้งสองกรอบ แต่ฉันใช้แฮมเครสต์ในการยืนยัน Hamcrest ช่วยให้คุณเขียนวิธีการยืนยันของคุณเองได้อย่างง่ายดาย ดังนั้นแทนที่จะเป็น

assertEquals(operation.getStatus(), Operation.Status.Active);

คุณสามารถเขียน

assertThat(operation, isActive());

นั่นทำให้คุณมีโอกาสใช้นามธรรมระดับสูงในการทดสอบของคุณ และทำให้การทดสอบของคุณมีประสิทธิภาพมากขึ้น

JUnit 4 Vs TestNG - การเปรียบเทียบโดย mkyong.com (ปรับปรุงเมื่อ 2013)

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

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

นอกจากนี้TestNG ยังครอบคลุมฟังก์ชันการทำงานหลักของ JUnit4ทั้งหมด มันไม่มีเหตุผลที่ฉันจะใช้ JUnit อีกต่อไป

พูดง่ายๆคือTestNG = JUnit + อีกมากมาย ทำไมต้องถกเถียงกัน? ไปคว้า TestNG :-)

คุณสามารถค้นหาเปรียบเทียบรายละเอียดเพิ่มเติมที่นี่

คำตอบของ Mike Stone เพิ่มเติม:

1) สิ่งที่บ่อยที่สุดที่ฉันใช้กลุ่มของ TestNG คือเมื่อฉันต้องการเรียกใช้วิธีการทดสอบเดียวในชุดทดสอบ ฉันเพิ่มการทดสอบนี้ในกลุ่ม "phil" แล้วเรียกใช้กลุ่มนี้ เมื่อฉันใช้ JUnit 3 ฉันจะแสดงความคิดเห็นเกี่ยวกับรายการสำหรับวิธีการทั้งหมด แต่เป็นวิธีที่ฉันต้องการเรียกใช้ในเมธอด "suite" แต่โดยปกติแล้วจะลืมที่จะยกเลิกการแสดงความคิดเห็นก่อนที่จะเช็คอิน กับกลุ่มต่างๆฉันไม่มีปัญหานี้อีกต่อไป

2) ขึ้นอยู่กับความซับซ้อนของการทดสอบการย้ายการทดสอบจาก JUnit3 ไปยัง TestNG สามารถทำได้โดยอัตโนมัติด้วย sed และสร้างคลาสพื้นฐานเพื่อแทนที่ TestCase ที่นำเข้าวิธีการยืนยัน TestNG ทั้งหมดแบบคงที่

ผมมีข้อมูลเกี่ยวกับการย้ายถิ่นของฉันจาก JUnit เพื่อ TestNG ที่นี่และที่นี่

ทำไมเราถึงใช้ TestNG แทน JUnit?

1. การประกาศ@BeforeClassและ@AfterClassวิธีการต้องเป็นแบบคงที่ใน JUnit ในขณะที่ TestNG มีความยืดหยุ่นมากกว่าในการประกาศวิธีการ แต่ก็ไม่มีข้อ จำกัด เหล่านี้

2. ใน TestNG เราสามารถ parametrize การทดสอบโดยใช้ 2 วิธี คำอธิบายประกอบ @Parameter หรือ @DataProvider

   i) @Parameterสำหรับกรณีทั่วไปซึ่งจำเป็นต้องมีการแมปค่าคีย์ (ข้อมูลถูกจัดเตรียมผ่านไฟล์ xml)

   ii) @DataProviderสำหรับกรณีที่ซับซ้อน ใช้อาร์เรย์ 2 มิติสามารถให้ข้อมูลได้

3. ใน TestNG เนื่องจากเมธอด @DataProvider ไม่จำเป็นต้องเป็นแบบคงที่เราสามารถใช้วิธีการให้บริการข้อมูลหลายวิธีในคลาสทดสอบเดียวกัน

4. การทดสอบการพึ่งพา:ใน TestNG หากการทดสอบครั้งแรกล้มเหลวการทดสอบที่อ้างอิงตามมาทั้งหมดจะถูกข้ามไปโดยไม่ถูกทำเครื่องหมายว่าล้มเหลว แต่ JUnit ทำเครื่องหมายว่าล้มเหลว

5. การจัดกลุ่ม:การทดสอบเดี่ยวอาจเป็นของหลายกลุ่มจากนั้นจึงเรียกใช้ในบริบทที่แตกต่างกัน (เช่นการทดสอบช้าหรือเร็ว) คุณลักษณะที่คล้ายกันมีอยู่ในหมวดหมู่ JUnit แต่ไม่มีคำอธิบายประกอบ @BeforeGroups / @AfterGroups TestNG ที่อนุญาตให้เริ่มต้นการทดสอบ / การฉีกขาด

6. ความเท่าเทียมกัน:หากคุณต้องการเรียกใช้การทดสอบเดียวกันพร้อมกันในหลายเธรด TestNG มีคำอธิบายประกอบที่ใช้งานง่ายในขณะที่ JUnit ไม่ได้เสนอวิธีง่ายๆในการทำเช่นนั้นนอกกรอบ

7. TestNG @DataProvider ยังสามารถรองรับ XML สำหรับการป้อนข้อมูล CSV หรือแม้แต่ไฟล์ข้อความธรรมดา

8. TestNG ช่วยให้คุณสามารถประกาศการอ้างอิงระหว่างการทดสอบและข้ามไปหากการทดสอบการพึ่งพาไม่ผ่าน

@Test (ขึ้นอยู่กับจุดเริ่มต้น = {"dependOnSomething"})

ฟังก์ชันนี้ไม่มีอยู่ใน JUnit

9. รายงาน:

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

ที่ด้านหน้า JUnit ข้อมูลทั้งหมดนี้ยังมีให้ผ่านทาง XML แต่ไม่มีรายงานนอกกรอบและคุณต้องพึ่งพาปลั๊กอิน

ลิงค์ทรัพยากร:

1. การเปรียบเทียบ JUnit กับ TestNG อย่างรวดเร็ว
2. JUnit กับ TestNG: กรอบการทดสอบใดที่คุณควรเลือก

บทช่วยสอนนี้มีความแตกต่างที่ดีควบคู่กันไป: TestNG Vs JUnit: อะไรคือความแตกต่าง?

คำถามของคุณดูเหมือนสองข้อสำหรับฉัน ในกรณีหนึ่งคุณต้องการเปรียบเทียบกรอบการทดสอบสองกรอบในทางกลับกันคุณต้องการใช้การทดสอบอย่างง่ายดายมีการยืนยันอย่างเป็นธรรมชาติ ฯลฯ ...

ตกลงประการแรก JUnit ได้เล่น Catchup กับ TestNG ในแง่ของฟังก์ชันการทำงานพวกเขาได้เชื่อมช่องว่างบางอย่างกับ v4 แต่ไม่ดีพอในความคิดของฉัน สิ่งต่างๆเช่นคำอธิบายประกอบและข้อมูลผู้ให้บริการยังดีกว่ามากใน TestNG นอกจากนี้ยังมีความยืดหยุ่นมากขึ้นในแง่ของการดำเนินการทดสอบเนื่องจาก TestNG มีการพึ่งพาการทดสอบการจัดกลุ่มและการสั่งซื้อ

JUnit ยังคงกำหนดให้วิธีการก่อน / หลังบางอย่างเป็นแบบคงที่ซึ่ง จำกัด สิ่งที่คุณสามารถทำได้ก่อนที่จะดำเนินการทดสอบ TestNG ไม่เคยมีปัญหานี้

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

ตอนนี้สำหรับสิ่งที่ฉันเชื่อว่าเป็นปัญหาที่แยกต่างหากวิธีการเขียนการทดสอบที่มีโครงสร้างดีอ่านได้และบำรุงรักษาได้ ส่วนใหญ่ฉันแน่ใจว่าคุณรู้ แต่สิ่งต่างๆเช่นFactory Pattern , Command PatternและPageObjects (หากเว็บไซต์ทดสอบของคุณ) มีความสำคัญเป็นอย่างยิ่งที่จะต้องมีชั้นของนามธรรมระหว่างสิ่งที่คุณทดสอบ (SUT) กับการทดสอบจริง คือ (การยืนยันตรรกะทางธุรกิจ) เพื่อให้มีการยืนยันมาก nicer คุณสามารถใช้Hamcrest ใช้ประโยชน์จากการสืบทอด / อินเทอร์เฟซของ javas เพื่อลดการทำซ้ำและบังคับใช้สามัญ

เกือบลืมใช้Test Data Builder Patternควบคู่ไปกับคำอธิบายประกอบ dataprovider ของ TestNG มีประโยชน์มาก

ความคิดเห็นของฉันเกี่ยวกับสิ่งที่ทำให้ TestNG มีประสิทธิภาพมากขึ้นอย่างแท้จริง:

1.  JUnit still requires the before/after class methods to be static, which limits
    what you can do prior to the running of tests, TestNG never has this issue.

2.  TestNG @Configuration methods can all take an optional argument to their 
    annotated methods in the form of a ITestResult, XmlTest, Method, or 
    ITestContext.  This allows you to pass things around that JUnit wouldn't 
    provide you.  JUnit only does this in listeners and it is limited in use.

3.  TestNG comes with some pre-made report generation classes that you can copy
     and edit and make into your own beautiful test output with very little 
     effort. Just copy the report class into your project and add a listener 
     to run it.  Also, ReportNG is available.

4.  TestNG has a handful of nice listeners that you can hook onto so you can do
     additional AOP style magic at certain phases during testing.