JUnit là một framework được sử dụng rộng rãi trong việc viết và chạy các bài kiểm thử tự động cho các ứng dụng Java. Được phát triển vào năm 1997 bởi Kent Beck và Erich Gamma, JUnit đã trở thành một tiêu chuẩn trong cộng đồng lập trình Java và được tích hợp sẵn trong các IDE như Eclipse hay NetBeans.
JUnit cung cấp cho chúng ta một cách tiếp cận đơn giản và có thể tái sử dụng khi cần thay đổi code hoặc thêm mới các bài kiểm thử. Trong bài viết này, chúng ta sẽ tìm hiểu về JUnit và cách sử dụng nó để viết và chạy các bài kiểm thử tự động cho ứng dụng Java của chúng ta.
Cách viết bài kiểm thử với JUnit
Để bắt đầu viết bài kiểm thử với JUnit, chúng ta cần tạo một class chứa các method kiểm thử. Class này sẽ được đánh dấu bằng annotation @Test và cần được kế thừa từ class TestCase của JUnit.
Ví dụ, chúng ta có một class Calculator với phương thức tính tổng hai số add(int a, int b). Bài kiểm thử cho phương thức này có thể được viết như sau:
import junit.framework.TestCase;
public class CalculatorTest extends TestCase {
@Test
public void testAdd() {
// Khởi tạo đối tượng Calculator
Calculator calculator = new Calculator();
// Gọi phương thức add và lưu giá trị trả về vào biến result
int result = calculator.add(5, 7);
// So sánh kết quả với giá trị đã biết trước
assertEquals(12, result);
}
}
Trong ví dụ trên, chúng ta đã sử dụng phương thức assertEquals() của lớp TestCase để so sánh giá trị trả về của phương thức add() với giá trị đã biết trước. Nếu hai giá trị này khác nhau, bài kiểm thử sẽ bị lỗi và thông báo sẽ được hiển thị.
Cách chạy bài kiểm thử với JUnit
Để chạy bài kiểm thử với JUnit, chúng ta có thể sử dụng các IDE như Eclipse hay NetBeans hoặc chạy từ dòng lệnh với công cụ Ant hoặc Maven.
Sử dụng IDE
Nếu bạn sử dụng Eclipse, bạn có thể tạo một project Java và thêm JUnit vào dependencies của project. Sau đó, chúng ta có thể tạo một class bài kiểm thử như trong phần trước và chạy nó bằng cách click chuột phải vào class và chọn "Run as" > "JUnit Test".
Trong NetBeans, chúng ta có thể thêm JUnit vào dependencies bằng cách vào "Project" > "Properties" > "Libraries" và click vào nút "Add library". Tương tự, chúng ta có thể tạo class bài kiểm thử và chạy nó bằng cách click chuột phải vào class và chọn "Test File".
Sử dụng Ant hoặc Maven
Nếu bạn sử dụng công cụ Ant hoặc Maven để quản lý các project Java của mình, bạn có thể sử dụng các plugin tương ứng để chạy bài kiểm thử với JUnit.
Với Ant, chúng ta có thể sử dụng <junit> task để chạy các bài kiểm thử. Đầu tiên, chúng ta cần import thư viện JUnit vào build.xml:
<project name="MyProject" default="test" basedir=".">
<!-- Import JUnit library -->
<path id="junit.classpath">
<fileset dir="${lib.dir}">
<include name="junit-4.*.jar"/>
<include name="hamcrest-core-*.jar"/>
</fileset>
</path>
<!-- Define test target -->
<target name="test">
<junit printsummary="yes" haltonfailure="yes">
<classpath refid="junit.classpath"/>
<formatter type="xml"/>
<batchtest todir="${reports.dir}">
<fileset dir="${src.dir}" includes="**/*Test.java"/>
</batchtest>
</junit>
</target>
</project>
Sau đó, chúng ta có thể chạy các bài kiểm thử bằng cách gọi lệnh ant test từ dòng lệnh.
Với Maven, chúng ta có thể sử dụng plugin maven-surefire-plugin để chạy các bài kiểm thử. Đầu tiên, chúng ta cần thêm dependency JUnit vào pom.xml:
<dependencies>
...
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
...
</dependencies>
Sau đó, chúng ta chỉ cần chạy lệnh mvn test từ dòng lệnh và Maven sẽ tự động tìm và chạy các bài kiểm thử trong project của chúng ta.
Tự động hóa việc kiểm thử bằng JUnit
Một trong những lợi ích lớn nhất của việc sử dụng JUnit là khả năng tự động hóa việc kiểm thử. Với JUnit, chúng ta có thể viết một lần và chạy lại nhiều lần để đảm bảo rằng code của chúng ta luôn hoạt động đúng.
Để tự động hóa việc kiểm thử, chúng ta có thể sử dụng các annotation và method bổ sung của JUnit như @Before, @After, @BeforeClass và @AfterClass.
@Before và @After
Annotation @Before và @After giúp chúng ta chuẩn bị và dọn dẹp sau khi chạy mỗi bài kiểm thử. Chúng ta có thể sử dụng @Before để khởi tạo các giá trị ban đầu cho bài kiểm thử và @After để giải phóng các tài nguyên sau khi bài kiểm thử được chạy xong.
Ví dụ, chúng ta có một class Calculator với phương thức divide(int a, int b) và chúng ta muốn đảm bảo rằng khi chia một số cho 0, sẽ có một exception được ném ra. Bài kiểm thử cho phương thức này có thể được viết như sau:
import junit.framework.TestCase;
public class CalculatorTest extends TestCase {
private Calculator calculator;
@Before
public void setUp() {
// Khởi tạo đối tượng Calculator trước khi chạy mỗi bài kiểm thử
calculator = new Calculator();
}
@After
public void tearDown() {
// Giải phóng tài nguyên sau khi chạy xong mỗi bài kiểm thử
calculator = null;
}
@Test
public void testDivideByZero() {
// Chia một số cho 0 và lưu exception vào biến e
Exception e = null;
try {
calculator.divide(10, 0);
} catch (Exception ex) {
e = ex;
}
// Kiểm tra xem exception đã được ném ra hay chưa
assertNotNull(e);
}
}
Trong ví dụ trên, chúng ta đã sử dụng @Before để khởi tạo đối tượng Calculator trước khi chạy mỗi bài kiểm thử và @After để giải phóng đối tượng này sau khi bài kiểm thử kết thúc.
@BeforeClass và @AfterClass
Trong một số trường hợp, chúng ta có thể cần khởi tạo các tài nguyên chung cho tất cả các bài kiểm thử trong class. Lúc này, chúng ta có thể sử dụng @BeforeClass và @AfterClass.
Ví dụ, chúng ta có một class DatabaseManager với phương thức connect() và disconnect() để kết nối và ngắt kết nối với database. Trong bài kiểm thử, chúng ta muốn đảm bảo rằng kết nối được thiết lập trước khi chạy bài kiểm thử và ngắt kết nối sau khi tất cả các bài kiểm thử đã được chạy xong. Bài kiểm thử có thể được viết như sau:
import junit.framework.TestCase;
public class DatabaseManagerTest extends TestCase {
private static DatabaseManager dbManager;
@BeforeClass
public static void setUp() {
// Khởi tạo một đối tượng DatabaseManager chung cho tất cả các bài kiểm thử
dbManager = new DatabaseManager();
// Kết nối database trước khi chạy các bài kiểm thử
dbManager.connect();
}
@AfterClass
public static void tearDown() {
// Ngắt kết nối với database sau khi tất cả các bài kiểm thử đã được chạy xong
dbManager.disconnect();
// Giải phóng tài nguyên
dbManager = null;
}
@Test
public void testGetUsername() {
// Kiểm tra username của người dùng từ database
String username = dbManager.getUsername(1);
assertEquals("John", username);
}
@Test
public void testGetEmail() {
// Kiểm tra email của người dùng từ database
String email = dbManager.getEmail(1);
assertEquals("john@gmail.com", email);
}
}
Trong ví dụ trên, chúng ta đã sử dụng @BeforeClass để kết nối với database trước khi chạy các bài kiểm thử và @AfterClass để ngắt kết nối sau khi tất cả các bài kiểm thử đã được chạy xong.
Kết luận: trên đây là một số cách sử dụng JUnit để viết và chạy các bài kiểm thử tự động cho ứng dụng Java của bạn. Chúng ta có thể tiết kiệm thời gian và công sức khi kiểm tra code của mình và đảm bảo tính đúng đắn của ứng dụng. Qua bài viết này, hy vọng bạn đã hiểu được cách sử dụng JUnit và áp dụng thành công nó vào trong quá trình phát triển phần mềm của mình.