วิธีรันเมธอดการทดสอบตามลำดับเฉพาะใน JUnit4

ฉันต้องการที่จะดำเนินการวิธีการทดสอบที่มีคำอธิบายประกอบตาม@Testลำดับที่เฉพาะเจาะจง

ตัวอย่างเช่น:

public class MyTest {
    @Test public void test1(){}
    @Test public void test2(){}
}

ฉันต้องการที่จะให้แน่ใจว่าจะเรียกใช้test1()ก่อนtest2()ทุกครั้งที่ผมทำงานแต่ฉันไม่สามารถหาคำอธิบายประกอบเช่นMyTest@Test(order=xx)

ฉันคิดว่ามันเป็นคุณสมบัติที่สำคัญมากสำหรับ JUnit หากผู้เขียน JUnit ไม่ต้องการคุณลักษณะการสั่งซื้อทำไม?

ฉันคิดว่ามันเป็นคุณสมบัติที่สำคัญมากสำหรับ JUnit หากผู้เขียน JUnit ไม่ต้องการคุณลักษณะการสั่งซื้อทำไม?

ฉันไม่แน่ใจว่ามีวิธีที่สะอาดในการทำเช่นนี้กับ JUnit สำหรับความรู้ของฉัน JUnit สันนิษฐานว่าการทดสอบทั้งหมดสามารถทำได้ตามคำสั่งโดยพลการ จากคำถามที่พบบ่อย:

ฉันจะใช้ฟิกซ์เจอร์ทดสอบได้อย่างไร

(... ) การสั่งซื้อการร้องขอวิธีทดสอบไม่รับประกันดังนั้น testOneItemCollection () อาจถูกเรียกใช้ก่อนที่จะทดสอบ testEmptyCollection () ( ... )

ทำไมถึงเป็นเช่นนั้น ฉันเชื่อว่าการจัดทำแบบทดสอบขึ้นอยู่กับการฝึกฝนที่ผู้เขียนไม่ต้องการประชาสัมพันธ์ การทดสอบควรเป็นอิสระพวกเขาไม่ควรเชื่อมโยงและละเมิดสิ่งนี้จะทำให้สิ่งต่าง ๆ ยากขึ้นที่จะบำรุงรักษาจะทำลายความสามารถในการทดสอบแยกต่างหาก (ชัด) ฯลฯ

ดังที่กล่าวไว้ถ้าคุณต้องการไปในทิศทางนี้จริงๆให้ลองใช้ TestNG เพราะมันรองรับการทดสอบวิธีการทำงานตามลำดับที่กำหนดเอง (และสิ่งต่าง ๆ เช่นการระบุวิธีการนั้นขึ้นอยู่กับกลุ่มของวิธีการ) เซดริก Beust อธิบายถึงวิธีการทำเช่นนี้ในคำสั่งของการดำเนินการของการทดสอบใน TestNG

หากคุณกำจัด Junit ที่มีอยู่ของคุณและดาวน์โหลดJUnit 4.11ขึ้นไปใน build path โค้ดต่อไปนี้จะรันวิธีทดสอบตามลำดับชื่อเรียงลำดับจากน้อยไปมาก

@FixMethodOrder(MethodSorters.NAME_ASCENDING)
public class SampleTest {

    @Test
    public void testAcreate() {
        System.out.println("first");
    }
    @Test
    public void testBupdate() {
        System.out.println("second");
    }
    @Test
    public void testCdelete() {
        System.out.println("third");
    }
}

หากการสั่งซื้อเป็นสิ่งสำคัญคุณควรทำการสั่งซื้อด้วยตัวเอง

@Test public void test1() { ... }
@Test public void test2() { test1(); ... }

โดยเฉพาะอย่างยิ่งคุณควรเขียนรายการเรียงสับเปลี่ยนคำสั่งซื้อที่เป็นไปได้บางส่วนหรือทั้งหมดเพื่อทดสอบหากจำเป็น

ตัวอย่างเช่น,

void test1(); 
void test2(); 
void test3(); 


@Test
public void testOrder1() { test1(); test3(); }

@Test(expected = Exception.class)
public void testOrder2() { test2(); test3(); test1(); }

@Test(expected = NullPointerException.class)
public void testOrder3() { test3(); test1(); test2(); }

หรือทดสอบเต็มรูปแบบของพีชคณิตทั้งหมด:

@Test
public void testAllOrders() {
    for (Object[] sample: permute(1, 2, 3)) {
        for (Object index: sample) {
            switch (((Integer) index).intValue()) {
                case 1: test1(); break; 
                case 2: test2(); break; 
                case 3: test3(); break; 
            }
        }
    }
}

นี่permute()คือฟังก์ชั่นที่เรียบง่ายซึ่งวนซ้ำที่เป็นไปได้ทั้งหมดลงในคอลเลกชันของอาร์เรย์

การย้ายไปยัง TestNG นั้นเป็นวิธีที่ดีที่สุด แต่ฉันไม่เห็นวิธีแก้ปัญหาที่ชัดเจนสำหรับ jUnit นี่เป็นวิธีแก้ปัญหา / การจัดรูปแบบที่อ่านได้มากที่สุดที่ฉันพบสำหรับ jUnit:

@FixMethodOrder(MethodSorters.NAME_ASCENDING)
public class SampleTest {
    @Test
    void stage1_prepareAndTest(){};

    @Test
    void stage2_checkSomething(){};

    @Test
    void stage2_checkSomethingElse(){};

    @Test
    void stage3_thisDependsOnStage2(){};

    @Test
    void callTimeDoesntMatter(){}
}

สิ่งนี้ทำให้มั่นใจได้ว่าสเตจ 2 ถูกเรียกใช้หลังจากสเตจ 1 และก่อนสเตจ 3

มันเป็นหนึ่งในปัญหาหลักที่ฉันต้องเผชิญเมื่อฉันทำงานกับ Junit และฉันมาพร้อมกับวิธีแก้ไขปัญหาต่อไปนี้ซึ่งทำงานได้ดีสำหรับฉัน:

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

import org.junit.runners.BlockJUnit4ClassRunner;
import org.junit.runners.model.FrameworkMethod;
import org.junit.runners.model.InitializationError;

public class OrderedRunner extends BlockJUnit4ClassRunner {

    public OrderedRunner(Class<?> clazz) throws InitializationError {
        super(clazz);
    }

    @Override
    protected List<FrameworkMethod> computeTestMethods() {
        List<FrameworkMethod> list = super.computeTestMethods();
        List<FrameworkMethod> copy = new ArrayList<FrameworkMethod>(list);
        Collections.sort(copy, new Comparator<FrameworkMethod>() {

            @Override
            public int compare(FrameworkMethod f1, FrameworkMethod f2) {
                Order o1 = f1.getAnnotation(Order.class);
                Order o2 = f2.getAnnotation(Order.class);

                if (o1 == null || o2 == null) {
                    return -1;
                }

                return o1.order() - o2.order();
            }
        });
        return copy;
    }
}

สร้างอินเทอร์เฟซเหมือนด้านล่าง:

 @Retention(RetentionPolicy.RUNTIME)


@Target({ ElementType.METHOD})

public @interface Order {
public int order();
}

ทีนี้สมมติว่าคุณมีคลาส A ที่คุณได้เขียนกรณีทดสอบหลายอย่างดังนี้:

(@runWith=OrderRunner.class)
Class A{
@Test
@Order(order = 1)

void method(){

//do something

}

}

ดังนั้นการประมวลผลจะเริ่มจากวิธีที่ชื่อว่า "method ()" ขอบคุณ!

ขณะนี้ JUnit อนุญาตให้วิธีการทดสอบรันการสั่งซื้อโดยใช้คำอธิบายประกอบในคลาส:

@FixMethodOrder(MethodSorters.NAME_ASCENDING)
@FixMethodOrder(MethodSorters.JVM)
@FixMethodOrder(MethodSorters.DEFAULT)

โดยวิธีการทดสอบเริ่มต้นจะทำงานตามลำดับตัวอักษร ดังนั้นเพื่อกำหนดวิธีการเฉพาะคุณสามารถตั้งชื่อพวกเขาเช่น:

a_TestWorkUnit_WithCertainState_ShouldDoSomething b_TestWorkUnit_WithCertainState_ShouldDoSomething c_TestWorkUnit_WithCertainState_ShouldDoSomething

คุณสามารถค้นหาตัวอย่างที่นี่

(เป็นยัง unreleased) การเปลี่ยนแปลงhttps://github.com/junit-team/junit/pull/386@SortMethodsWithแนะนำ https://github.com/junit-team/junit/pull/293อย่างน้อยทำให้การสั่งซื้อสามารถคาดเดาได้โดยไม่ต้องทำเช่นนั้น (ใน Java 7 สามารถสุ่มได้ค่อนข้างมาก)

ดูรายงาน JUnit JUnit ถูกจัดระเบียบโดยแพ็คเกจแล้ว แต่ละแพ็กเกจมีคลาส TestSuite (หรือมี) ซึ่งแต่ละคลาสจะรัน TestCases หลายชุด TestCase แต่ละแห่งสามารถมีวิธีทดสอบหลายแบบpublic void test*()ซึ่งแต่ละอันจะกลายเป็นตัวอย่างของคลาส TestCase ที่พวกเขาอยู่ แต่ละวิธีทดสอบ (อินสแตนซ์ TestCase) มีชื่อและเกณฑ์การผ่าน / ไม่ผ่าน

สิ่งที่ฝ่ายจัดการของฉันต้องการคือแนวคิดของรายการTestStepแต่ละรายการซึ่งแต่ละรายการจะรายงานเกณฑ์การผ่าน / ไม่ผ่านของตนเอง ความล้มเหลวของขั้นตอนการทดสอบใด ๆ จะต้องไม่ป้องกันการดำเนินการตามขั้นตอนการทดสอบที่ตามมา

ในอดีตผู้พัฒนาการทดสอบในตำแหน่งของฉันจัดคลาส TestCase เป็นแพ็คเกจที่สอดคล้องกับส่วนของผลิตภัณฑ์ภายใต้การทดสอบสร้างคลาส TestCase สำหรับการทดสอบแต่ละครั้งและทำให้แต่ละขั้นตอนการทดสอบแยกเป็น "ขั้นตอน" ในการทดสอบ สมบูรณ์ด้วยเกณฑ์การผ่าน / ไม่ผ่านของตนเองในเอาต์พุต JUnit แต่ละ TestCase เป็น "การทดสอบ" แบบสแตนด์อโลน แต่วิธีการแต่ละอย่างหรือการทดสอบ "ขั้นตอน" ภายใน TestCase จะต้องเกิดขึ้นในลำดับที่เฉพาะเจาะจง

กระบวนการ TestCase เป็นขั้นตอนของ TestCase และผู้ออกแบบการทดสอบมีเกณฑ์การผ่าน / ไม่ผ่านที่แยกต่างหากต่อขั้นตอนการทดสอบ ตอนนี้ขั้นตอนการทดสอบจะล้มเหลวและการทดสอบ (แน่นอน) ล้มเหลว

ตัวอย่างเช่น:

Class testStateChanges extends TestCase

public void testCreateObjectPlacesTheObjectInStateA()
public void testTransitionToStateBAndValidateStateB()
public void testTransitionToStateCAndValidateStateC()
public void testTryToDeleteObjectinStateCAndValidateObjectStillExists()
public void testTransitionToStateAAndValidateStateA()
public void testDeleteObjectInStateAAndObjectDoesNotExist()
public void cleanupIfAnythingWentWrong()

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

ทุกคนสามารถอธิบายวิธีการสั่งซื้อ JUnit พร้อมวิธีการทดสอบสัญญาณรบกวนซึ่งจะสนับสนุนเกณฑ์การผ่าน / ไม่ผ่านของแต่ละขั้นตอนการทดสอบตามลำดับอย่างที่อธิบายไว้ด้านบนและต้องการโดยฝ่ายบริหารของฉัน

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

อัปเดต JUnit 5 (และความคิดเห็นของฉัน)

ฉันคิดว่ามันเป็นคุณสมบัติที่สำคัญมากสำหรับ JUnit หากผู้เขียน JUnit ไม่ต้องการคุณลักษณะการสั่งซื้อทำไม?

โดยค่าเริ่มต้นไลบรารีทดสอบหน่วยจะไม่พยายามดำเนินการทดสอบตามลำดับที่เกิดขึ้นในไฟล์ต้นฉบับ
JUnit 5 ในฐานะ JUnit 4 ทำงานในลักษณะนั้น ทำไม เพราะถ้าสั่งซื้อที่สำคัญก็หมายความว่าการทดสอบบางอย่างเป็นคู่ระหว่างพวกเขาและที่เป็นที่ไม่พึงประสงค์สำหรับการทดสอบหน่วย
ดังนั้น@Nestedคุณลักษณะที่แนะนำโดย JUnit 5 จึงเป็นไปตามวิธีการเริ่มต้นเดียวกัน

แต่สำหรับการทดสอบการรวมคำสั่งของวิธีการทดสอบอาจมีความสำคัญเนื่องจากวิธีการทดสอบอาจเปลี่ยนสถานะของแอปพลิเคชันในแบบที่คาดไว้โดยวิธีการทดสอบอื่น ตัวอย่างเช่นเมื่อคุณเขียนการทดสอบการรวมสำหรับการประมวลผลการชำระเงินร้านค้าวิธีการทดสอบแรกที่จะดำเนินการคือการลงทะเบียนลูกค้าที่สองคือการเพิ่มรายการในตะกร้าและคนสุดท้ายที่จะทำการเช็คเอาต์ หากนักวิ่งทดสอบไม่เคารพคำสั่งนั้นสถานการณ์การทดสอบจะสมบูรณ์และจะล้มเหลว
ดังนั้นใน JUnit 5 (จากเวอร์ชั่น 5.4) คุณมีความเป็นไปได้ที่จะตั้งค่าลำดับการดำเนินการโดยใส่คำอธิบายประกอบการทดสอบด้วย@TestMethodOrder(OrderAnnotation.class)และโดยระบุคำสั่งด้วย@Order(numericOrderValue)สำหรับวิธีการที่คำสั่งนั้นสำคัญ

ตัวอย่างเช่น :

@TestMethodOrder(OrderAnnotation.class) 
class FooTest {

    @Order(3)
    @Test
    void checkoutOrder() {
        System.out.println("checkoutOrder");
    }

    @Order(2)
    @Test
    void addItemsInBasket() {
        System.out.println("addItemsInBasket");
    }

    @Order(1)
    @Test
    void createUserAndLogin() {
        System.out.println("createUserAndLogin");
    }
}

ผลผลิต:

createUserAndLogin

addItemsInBasket

checkoutOrder

โดยวิธีการระบุ@TestMethodOrder(OrderAnnotation.class)ดูเหมือนไม่จำเป็น (อย่างน้อยในรุ่น 5.4.0 ฉันทดสอบ)

หมายเหตุด้านข้าง
เกี่ยวกับคำถาม: JUnit 5 เป็นตัวเลือกที่ดีที่สุดในการเขียนการทดสอบการรวมหรือไม่ ฉันไม่คิดว่ามันควรจะเป็นเครื่องมือแรกที่ต้องพิจารณา (แตงกวาและผู้ร่วมงานมักจะนำคุณค่าและคุณสมบัติที่เฉพาะเจาะจงมากขึ้นสำหรับการทดสอบการรวมเข้าด้วยกัน) แต่ในบางกรณีการทดสอบการรวมเข้าด้วยกันกรอบ JUnit ก็เพียงพอแล้ว ดังนั้นจึงเป็นข่าวดีว่ามีคุณสมบัติอยู่

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

สิ่งที่คุณต้องการมีเหตุผลอย่างสมบูรณ์แบบเมื่อกรณีทดสอบถูกเรียกใช้เป็นชุด

น่าเสียดายที่ไม่มีเวลาให้วิธีแก้ปัญหาที่สมบูรณ์ในตอนนี้ แต่ดูที่คลาส:

org.junit.runners.Suite

ซึ่งช่วยให้คุณสามารถเรียกกรณีทดสอบ (จากชั้นทดสอบใด ๆ ) ในลำดับที่เฉพาะเจาะจง

สิ่งเหล่านี้อาจถูกใช้เพื่อสร้างการทำงานการรวมหรือการทดสอบระบบ

สิ่งนี้จะทำให้การทดสอบหน่วยของคุณเป็นไปตามลำดับโดยไม่มีคำสั่งเฉพาะ (ตามที่แนะนำ) ไม่ว่าคุณจะเรียกใช้สิ่งเหล่านั้นเช่นนั้นหรือไม่จากนั้นใช้การทดสอบอีกครั้งในฐานะเป็นส่วนหนึ่งของภาพใหญ่ขึ้น

เราใช้ / รับมรดกรหัสเดียวกันสำหรับการทดสอบหน่วยการรวมระบบและบางครั้งการขับเคลื่อนข้อมูลบางครั้งกระทำการขับเคลื่อนและบางครั้งทำงานเป็นชุด

ดูโซลูชันของฉันที่นี่: "Junit and java 7"

ในบทความนี้ฉันอธิบายวิธีเรียกใช้การทดสอบ Junit ตามลำดับ - "เหมือนกับในซอร์สโค้ดของคุณ" การทดสอบจะทำงานตามลำดับเมื่อวิธีทดสอบของคุณปรากฏในไฟล์คลาส

http://intellijava.blogspot.com/2012/05/junit-and-java-7.html

แต่ดังที่ Pascal Thivent กล่าวว่านี่ไม่ใช่วิธีปฏิบัติที่ดี

ด้วย JUnit 5.4 คุณสามารถระบุคำสั่งซื้อ:

@Test
@Order(2)
public void sendEmailTestGmail() throws MessagingException {

คุณต้องใส่คำอธิบายประกอบชั้นเรียนของคุณ

@TestMethodOrder(OrderAnnotation.class)

https://junit.org/junit5/docs/current/user-guide/#writing-tests-test-execution-order

ฉันใช้สิ่งนี้ในโครงการของฉันและใช้งานได้ดีมาก!

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

ดังนั้นเพียงตั้งชื่อการทดสอบตามลำดับตัวอักษรที่คุณต้องการ นอกจากนี้โปรดทราบว่าชื่อการทดสอบจะต้องเริ่มต้นด้วยการทดสอบคำว่า เพียงระวังตัวเลข

test12 จะทำงานก่อน test2

ดังนั้น:

testA_MyFirstTest testC_ThirdTest testB_ATestThatRunsSecond

กรุณาตรวจสอบนี้: https://github.com/TransparentMarket/junit มันรันการทดสอบตามลำดับที่พวกเขาระบุ (กำหนดไว้ในไฟล์คลาสที่รวบรวม) นอกจากนี้ยังมีชุด AllTests เพื่อเรียกใช้การทดสอบที่กำหนดโดยแพ็คเกจย่อยก่อน การใช้การใช้ AllTests สามารถขยายโซลูชันในการกรองคุณสมบัติ (เราเคยใช้คำอธิบายประกอบ @Fast แต่ยังไม่ได้เผยแพร่)

นี่คือส่วนขยายของ JUnit ที่สามารถสร้างพฤติกรรมที่ต้องการ: https://github.com/aafuks/aaf-junit

ฉันรู้ว่าสิ่งนี้ขัดต่อปรัชญาของ JUnit แต่เมื่อใช้ JUnit ในสภาพแวดล้อมที่ไม่ใช่การทดสอบหน่วยที่เข้มงวด

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

ฉันรู้ว่าสิ่งนี้ไม่เกี่ยวข้องกับคำถามนี้อย่างสมบูรณ์ แต่อาจช่วยกำหนดเป้าหมายปัญหาที่ถูกต้องได้

คุณสามารถใช้หนึ่งในรหัสเหล่านี้:

@FixMethodOrder(MethodSorters.JVM)OR `@FixMethodOrder(MethodSorters.DEFAULT)` OR `@FixMethodOrder(MethodSorters.NAME_ASCENDING)` before your test class like this:


@FixMethodOrder(MethodSorters.NAME_ASCENDING)


public class BookTest { ...}