JUnit Disable Test Example

Alvin ReyesNovember 6th, 2015Last Updated: March 21st, 2019

0 69 2 minutes read

1. Introduction

There are instances that our test cases aren’t ready yet and it would almost be certain that when we run our builds with these, there is a high probability that our test executions will fail. This can be avoided using the @Ignore annotation.

Developers sometimes just pass the test case to avoid build failures (assert(true)). This is a bad practice and should be avoided. The @Ignore annotation is a better alternative as it will allow the runner to just ignore the test case ensuring that it won’t be part of the build run.

This annotation can be used by developers to tag a specific test case as disabled. This means that even if we run our builds, the JUnit test runner won’t bother running them since it assumes that it’s not yet ready or intentionally disabled.

2. Source

Let’s start with creating an implementation class. The following code will be our implementation class that we will create a test case from.

MessageService.java

package com.areyes.junit.svc;

/**
 * The Class MessageService.
 */
public class MessageService {
	
	

	/** The message. */
	private String message;


	/**
	 * Instantiates a new message service.
	 *
	 * @param message the message
	 */
	public MessageService(String message) {
		this.message = message;
	}

	/**
	 * Prints the message.
	 *
	 * @return the string
	 */
	public String printMessage() {
		return message;
	}

	/**
	 * Salutation message.
	 *
	 * @return the string
	 */
	public String salutationMessage() {
		message = "Hi!" + message;
		return message;
	}
	
	/**
	 * This will be the method to get the salutation messages specifically for executives.
	 * @return
	 */
	public String salutationMessageForExecutives() {
		return "this is not yet implemented";
	}

}

As it can be seen on the class above, we have a method that has not been implemented yet. We don’t want our test case to run this don’t we? So in order for our test case to ignore this, we use the @Ignore on the specific test. See the test case below.

MessageServiceTest.java

package com.areyes.junit.svc;

import static org.junit.Assert.*;

import org.junit.After;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
import static org.hamcrest.CoreMatchers.isA;

public class MessageServiceTest {

	private String CONST_MSG = "Message is me";
	private MessageService msgService = new MessageService(CONST_MSG);
	
	@Test
	public void testPrintMessage() {
		//	Check type return
		assertThat(msgService.printMessage(), isA(String.class));
		assertEquals(CONST_MSG, msgService.printMessage());
		
	}
	
	@Test
	public void testSalutationMessage() {
		String messageSal = msgService.salutationMessage();
		assertThat(messageSal, isA(String.class));
		assertEquals("Hi!" + CONST_MSG,messageSal);
	}


	@Ignore
	@Test
	public void testSalutationMessageForExecutives() {
		assertThat(msgService.salutationMessageForExecutives(), isA(String.class));
		assertEquals(CONST_MSG, msgService.salutationMessage());
	}
}

As seen on the testSalutationMessageForExecutives() method, it’s as simple as putting an@Ignoreannotation on your test case. This is our way (developers) to tell the JUnit Runner that we don’t want to run this specific case since we haven’t finished the implementation yet.