TestNG Tutorial 정리 01

Selenium 과 같이 TestNG가 많이 사용되는 것 같아 TestNG에 대해서도 정리를 해 두기로 했습니다.

지난 프로젝트에서 jUnit을 사용해서 비슷한 개념의 TestNG를 배우는게 그렇게 부담이 되지는 않아 다행이네요.

TestNG만의 특징 및 장점을 파악해 둬서 나중에 실무에서 유용하게 사용해야 되겠습니다.

아래 튜토리얼은 구글링 하다가 http://www.mkyong.com/tutorials/testng-tutorials/ 에서 찾은 글들 입니다.

TestNG Tutorial 1 – Basic usage

import java.util.*;
import org.testng.Assert;
import org.testng.annotations.*;
 
public class TestNGTest1 {
 
    private Collection collection;
 
    @BeforeClass
    public void oneTimeSetUp() {
        // one-time initialization code   
    	System.out.println("@BeforeClass - oneTimeSetUp");
    }
 
    @AfterClass
    public void oneTimeTearDown() {
        // one-time cleanup code
    	System.out.println("@AfterClass - oneTimeTearDown");
    }
 
    @BeforeMethod
    public void setUp() {
        collection = new ArrayList();
        System.out.println("@BeforeMethod - setUp");
    }
 
    @AfterMethod
    public void tearDown() {
        collection.clear();
        System.out.println("@AfterMethod - tearDown");
    }
 
    @Test
    public void testEmptyCollection() {
        Assert.assertEquals(collection.isEmpty(),true);
        System.out.println("@Test - testEmptyCollection");
    }
 
    @Test
    public void testOneItemCollection() {
        collection.add("itemA");
        Assert.assertEquals(collection.size(),1);
        System.out.println("@Test - testOneItemCollection");
    }
}

Result

@BeforeClass - oneTimeSetUp
@BeforeMethod - setUp
@Test - testEmptyCollection
@AfterMethod - tearDown
@BeforeMethod - setUp
@Test - testOneItemCollection
@AfterMethod - tearDown
@AfterClass - oneTimeTearDown
PASSED: testEmptyCollection
PASSED: testOneItemCollection

TestNG Tutorial 2 – Expected Exception Test

import org.testng.annotations.*;
 
/**
 * TestNG Expected Exception Test
 * @author mkyong
 *
 */
public class TestNGTest2 {
 
	@Test(expectedExceptions = ArithmeticException.class)  
	public void divisionWithException() {  
	  int i = 1/0;
	}  
 
}

In above example, the divisionWithException() method will throw an ArithmeticException Exception, since this is an expected exception, so the unit test will pass.

위 예제에서는 annotation으로 ArithmeticException.class 가 예상되는 메소드라고 선언해 줬습니다.

jUnit이랑 Exception 테스트하는 부분은 비슷하네요.

divisionWithException() method가 ArithmeticException Exception을 throw 할 테니까 이 테스트는 pass 되게 됩니다.

TestNG Tutorial 3 – Ignore Test

This “Ignored” means the method is not ready to test, the TestNG engine will just bypass this method.

완료하지 않은 테스트 메소드의 실행을 하고 싶지 않을 때 TestNG는 아래와 같이 enabled=false annotation을 사용합니다.

jUnit에서는 ignore 를 사용햇던 것 같은데 약간 사용법이 다르군요.

import org.testng.annotations.*;
 
/**
 * TestNG Ignore Test
 * @author mkyong
 *
 */
public class TestNGTest3 {
 
	@Test(enabled=false)
	public void divisionWithException() {  
	  System.out.println("Method is not ready yet");
	}  
 
}

In above example, TestNG will not test the divisionWithException() method.

TestNG Tutorial 4 – Time Test

The “Time Test” means if an unit test takes longer than the specified number of milliseconds to run, the test will terminated and mark as failed.

이 테스트를 실행하는데 일정 시간 이상 지나면 그냥 fail로 처리하고 싶을 때 TestNG에서는 이 timeout annotation을 사용합니다.

import org.testng.annotations.*;
 
/**
 * TestNG TimeOut Test
 * @author mkyong
 *
 */
public class TestNGTest4 {
 
	@Test(timeOut = 1000)  
	public void infinity() {  
		while (true);  
	}  
 
}

In above example, the infinity() method will not return, so the TestNG engine will mark it as failed and throw an exception

FAILED: infinity
org.testng.internal.thread.ThreadTimeoutException: 
Method public void TestNGTest4.infinity() didn't finish within the time-out 1000
... Removed 18 stack frames

TestNG Tutorial 5 – Suite Test

The “Suite Test” means bundle a few unit test cases and run it together.

In TestNG, XML file is use to define the suite test. The below XML file means both unit test “TestNGTest1” and “TestNGTest2” will execute together.

이 Suite Test는 Selenium을 다루는 글에서도 한번 다룬 적이 있습니다.

두 개 이상의 테스트 클래스를 테스트하고 싶을 때 사용합니다.

<!DOCTYPE suite SYSTEM "http://beust.com/testng/testng-1.0.dtd" >
<suite name="My test suite">
  <test name="testing">
    <classes>
       <class name="TestNGTest1" />
       <class name="TestNGTest2" />
    </classes>
  </test>
</suite>

Beside classes bundle testing, TestNG provides a “Grouping” feature to bundle few methods as a single unit for testing, where every method is tie to a group.

For example, Here’s a class with four methods, three groups (method1, method2 and method3)

import org.testng.annotations.*;
 
/**
 * TestNG Grouping
 * @author mkyong
 *
 */
public class TestNGTest5_2_0 {
 
	@Test(groups="method1")
	public void testingMethod1() {  
	  System.out.println("Method - testingMethod1()");
	}  
 
	@Test(groups="method2")
	public void testingMethod2() {  
		System.out.println("Method - testingMethod2()");
	}  
 
	@Test(groups="method1")
	public void testingMethod1_1() {  
		System.out.println("Method - testingMethod1_1()");
	}  
 
	@Test(groups="method4")
	public void testingMethod4() {  
		System.out.println("Method - testingMethod4()");
	}    
}

You can execute the unit test with group “method1” only.

<!DOCTYPE suite SYSTEM "http://beust.com/testng/testng-1.0.dtd" >
<suite name="My test suite">
  <test name="testing">
  	<groups>
      <run>
        <include name="method1"/>
      </run>
    </groups>
    <classes>
       <class name="TestNGTest5_2_0" />
    </classes>
  </test>
</suite>

Result

Method - testingMethod1_1()
Method - testingMethod1()

TestNG Grouping is highly flexible and useful, especially when you implement it in your project integration testing.