[Z] use the runwith annotation to change the default execution class of JUnit and implement its own listener

Use the runwith annotation to change the default execution class of JUnit and implement its own listener unit test at ordinary times. If the runwith annotation is not used, JUnit will use the default execution class suite for execution, as shown below:

[Java]View plaincopy

1. Public class testclass {
2. @ Test public void T1 (){}
3. }

JUnit allows you to specify other unit test execution classes. You only need to inherit org. JUnit. Runners. blockjunit4classrunner from the test execution class. Spring execution class springjunit4classrunner inherits this class. We usually use spring. To make it easier to reference the configuration file, we use the execution class implemented by spring for unit testing. The unit test execution class will look like this:

[Java]View plaincopy

1. @ Runwith (springjunit4classrunner. Class)
2. @ Contextconfiguration (locations = {"classpath *:/spring1.xml", "classpath *:/spring2.xml "})
3. @ Testexecutionlisteners ({dependencyinjectiontestexecutionlistener. Class, transactionaltestexecutionlistener. Class })
4. @ Transactional
5. Public class testclass {
6. @ Inject
7. // This class will be injected during execution. Here it is injection by type. To inject by name, add the @ named annotation, for example, @ named ("class1 ")
8. // The implementation class can be annotated with @ named ("class1") or configured in the configuration file
9. Class1 class1;
11. @ Test
12. Public void T1 (){}
13. }

The annotations used are described as follows:

@ Runwith: This is the specified unit test execution class. springjunit4classrunner. Class is specified here;

@ Contextconfiguration: Specifies the path of the spring configuration file. You can specify multiple files at the same time;

@ Testexecutionlisteners: specifies some actions that can be performed before the test class is executed, such as dependencyinjectiontestexecutionlistener. class to inject the dependencies in a test class, transactionaltestexecutionlistener. class is used to manage transactions. Both of these are built-in with srping. We can also implement our own listener class to complete our own operations. We only need to continue with the class Org. springframework. test. context. support. abstracttestexecutionlistener. For more information, see dependencyinjectiontestexecutionlistener. class implementation, I will post the instance later. The listener is executed before the implementation class is executed and before the test method of the implementation class is executed, which is related to the implementation of listener.

@ Transactional: @ transactional is not required here. It is consistent with transactionaltestexecutionlistener in @ testexecutionlisteners. class is used together to ensure that the test data in the inserted database is rolled back after the test, and the inserted data is deleted to ensure the database is clean. If the specified @ transactional is not displayed, the data inserted into the database is actually inserted.

Our unit tests usually involve database operations, so we need to read data from the database and perform logical processing. In order to ensure the database is clean, to ensure the accuracy and correctness of the test data, we 'd better Insert the test data we prepared before the test, and then delete the data after the test is complete, in this case, we can add a listener to prepare the test data we need and combine it with the transaction management above, so that we won't actually commit it to the database.

The following example is a simple listener implementation, but the function is to print the configuration file path in the annotation we configured on method, because there are a lot of code to integrate dbunit and insert the database, I will not post it here. 1. First, we need to prepare an annotation to identify the data file whose parameters are used for testing: dbunittestdata. Java

[Java]View plaincopy

1. @ Retention (retentionpolicy. runtime)
2. @ Target (elementtype. Method)
3. @ Inherited
4. @ Brief ented
5. Public @ interface dbunittestdata {
7. Public String [] datasetlocations ();
8. }

2. Compile listener. The Listener name is defined as dbunittestexecutionlistener. Class: dbunittestexecutionlistener. java.

[Java]View plaincopy

1. Import org. springframework. Test. Context. testcontext;
2. Import org. springframework. Test. Context. testexecutionlistener;
4. Public class dbunittestexecutionlistener implements testexecutionlistener {
6. Public void preparetestinstance (testcontext) throws exception {
7. }
9. Public void beforetestclass (testcontext) throws exception {
10. // Nothing to do
11. }
13. Public void aftertestclass (testcontext) throws exception {
14. // Nothing to do
15. }
17. Public void beforetestmethod (testcontext) throws exception {
18. Dbunittestdata dbunitrefresh = testcontext. gettestmethod (). getannotation (dbunittestdata. Class );
19. If (dbunitrefresh = NULL ){
20. Return;
21. }
22. String [] datasetlocations = dbunitrefresh. datasetlocations ();
23. Loadtestdata (testcontext, datasetlocations );
24. }
26. Public void aftertestmethod (testcontext) throws exception {
27. // Nothing to do
28. }
30. Private void loadtestdata (testcontext, string [] datasetlocations ){
31. If (datasetlocations = NULL | datasetlocations. Length = 0 ){
32. Return;
33. }
34. For (string datasetlocation: datasetlocations ){
35. // Do what you want to do with the data set files
36. System. Out. println (datasetlocation );
37. }
38. }
40. }

3. Add the listener implementation class to @ testexecutionlisteners of the test class and add the annotation @ dbunittestdata to the method. In this case, the test class will be like this:

[Java]View plaincopy

1. @ Runwith (springjunit4classrunner. Class)
2. @ Contextconfiguration (locations = {"classpath *:/spring1.xml", "classpath *:/spring2.xml "})
3. @ Testexecutionlisteners ({dependencyinjectiontestexecutionlistener. Class, transactionaltestexecutionlistener. Class, dbunittestexecutionlistener. Class })
4. @ Transactional
5. Public class testclass {
6. @ Inject
7. // This class will be injected during execution. Here it is injection by type. To inject by name, add the @ named annotation, for example, @ named ("class1 ")
8. // The implementation class can be annotated with @ named ("class1") or configured in the configuration file
9. Class1 class1;
11. @ Test
12. @ Dbunittestdata (datasetlocations = {"classpath:/testdata/testdata1.xml", "classpath:/testdata/testdata2.xml "})
13. Public void T1 (){}
14. }

4. Run this method to view the data file path of the @ dbunittestdata annotation.

[Z] use the runwith annotation to change the default execution class of JUnit and implement its own listener