Getting the most out of your next generation JVM testing framework

Ge#ng the most out of your
next genera2on JVM tes2ng framework
JUnit 5 Spock
Benjamin Muschko

View Slide

AUTOMATED
ASCENT
bmuschko
bmuschko
bmuschko.com
About the speaker
automatedascent.com

View Slide

Which test
framework do you
use?

View Slide

JUnit 5 in a nutshell
Complete rewrite of JUnit
Modular & extensible
Forward & backward compa2ble

View Slide

Far more than a version upgrade

View Slide

JUnit Jupiter
The programming
and extension
model

View Slide

Spock Framework
BDD tes2ng
framework

View Slide

Spock, short and sweet
Tests are wriLen in Groovy
Highly expressive, extensible
JUnit 4-compa2ble with test runner

View Slide

given
when
then
defines the key ac2on
known state or data
verifies expected outcome
Specifica2on of a test

View Slide

Tests need to
be expressive

View Slide

import org.junit.jupiter.api.DisplayName; 
import org.junit.jupiter.api.Test; 
 
import static org.junit.jupiter.api.Assertions.assertEquals; 
 
public class DescriptiveTest { 
private final ArithmeticOperation arithmeticOperation =↵
new ArithmeticOperation(); 
 
@Test 
@DisplayName("can add two numbers") 
void canAdd() { 
assertEquals(3, arithmeticOperation.add(1, 2)); 
} 
}
Descrip2ve tests

View Slide

Execu2ng tests in IntelliJ

View Slide

import spock.lang.Specification 
import spock.lang.Subject 
 
class DescriptiveTest extends Specification { 
@Subject def arithmeticOperation =↵
new ArithmeticOperation() 
 
def "can add two numbers"() { 
when: 
def result = arithmeticOperation.add(1, 2)
then:
result == 3  
} 
}
Descrip2ve tests

View Slide

Execu2ng tests in IntelliJ

View Slide

Tests
may require
preparation

View Slide

import org.junit.jupiter.api.AfterEach; 
import org.junit.jupiter.api.BeforeEach; 
 
public class FixtureSetupCleanup { 
private Path testFile; 
 
@BeforeEach 
void setup() throws IOException { 
testFile = Files.createTempFile("junit5", ".tmp"); 
} 
 
@AfterEach 
void cleanup() { 
testFile.toFile().delete(); 
} 
}
Fixture set up and tear down

View Slide

import spock.lang.Specification 
import spock.lang.Subject 
 
class FixtureSetupCleanup extends Specification { 
def testFile 
 
def setup() { 
testFile = Files.createTempFile("junit5", ".tmp") 
} 
 
def cleanup() { 
testFile.toFile().delete() 
} 
}
Fixture set up and tear down

View Slide

Putting tests
to sleep

View Slide

import org.junit.jupiter.api.Disabled; 
 
public class IgnoredTest { 
 
@Test 
@Disabled("for demonstration purposes") 
void canAdd() { 
} 
}
Disabling tests

View Slide

import spock.lang.Ignore 
 
class IgnoredTest extends Specification { 
 
@Ignore("for demonstration purposes") 
def canAdd() { 
expect: 
arithmeticOperation.add(1, 2) == 3 
} 
}
Disabling tests

View Slide

import org.junit.jupiter.api.condition.EnabledIfSystemProperty; 
 
public class ConditionalExecutionTest { 
private final static String SYS_PROP_KEY = "junit5.test.enabled"; 
private final static String SYS_PROP_TRUE_VALUE = "true"; 
 
@EnabledIfSystemProperty(named = SYS_PROP_KEY,↵
matches = SYS_PROP_TRUE_VALUE) 
@Test 
void testOnlyOnSystemSystemProperty() { 
} 
}
Built-in condi2onals

View Slide

import static org.junit.jupiter.api.Assumptions.assumeTrue; 
 
private final static String SYS_PROP_KEY = "junit5.test.enabled"; 
private final static String SYS_PROP_TRUE_VALUE = "true"; 
 
@Test 
void testOnlyOnSystemPropertySet() { 
assumeTrue(SYS_PROP_TRUE_VALUE↵
.equals(System.getProperty(SYS_PROP_KEY))); 
} 
}
Alterna2ve condi2onal syntax

View Slide

import org.junit.jupiter.api.extension.*; 
 
import static org.junit.jupiter.api.extension.ConditionEvaluationResult.*; 
 
public static class SystemPropertyConditionalExtension implements ExecutionCondition { 
@Override 
public ConditionEvaluationResult evaluateExecutionCondition(ExtensionContext↵ 
context) { 
String sysPropValue = System.getProperty(SYS_PROP_KEY); 
boolean enabled = SYS_PROP_TRUE_VALUE.equals(sysPropValue); 
 
if (enabled) { 
return enabled(String.format("System property '%s' evaluates to true",↵ 
SYS_PROP_KEY)); 
} 
 
return disabled(String.format("System property '%s' evaluates to false”,↵ 
SYS_PROP_KEY)); 
} 
}
Custom condi2onals

View Slide

import org.junit.jupiter.api.extension.ExtendWith; 
 
 
@ExtendWith(SystemPropertyConditionalExtension.class) 
@Test 
void testOnlyOnSystemPropertySetByExtension() { 
} 
}
Using custom condi2onals

View Slide

import spock.lang.Requires 
 
class ConditionalExecutionTest extends Specification { 
private final static String SYS_PROP_KEY = "spock.test.enabled" 
private final static String SYS_PROP_TRUE_VALUE = "true" 
@Subject def arithmeticOperation = new ArithmeticOperation() 
 
@Requires({ SYS_PROP_TRUE_VALUE == sys[SYS_PROP_KEY] }) 
def "can add"() { 
expect: 
} 
}
Condi2onal test execu2on

View Slide

Expect
things to
misbehave

View Slide

import static org.junit.jupiter.api.Assertions.assertThrows; 
 
public class ExpectedExceptionTest { 
private final FileReader fileReader =↵
new DefaultFileReader(); 
 
@Test 
void cannotReadNonExistentFile() { 
assertThrows(IOException.class, () -> { 
fileReader.readContent(Paths.get("hello.text")); 
}); 
} 
}
Expec2ng thrown excep2ons

View Slide

import spock.lang.FailsWith 
 
class ExpectedExceptionTest extends Specification { 
@Subject def fileReader = new DefaultFileReader() 
 
@FailsWith(IOException) 
def "throws exception if file contents cannot be read"() { 
expect: 
fileReader.readContent(Paths.get('hello.text')) 
} 
}

View Slide

class ExpectedExceptionTest extends Specification { 
@Subject def fileReader = new DefaultFileReader() 
 
def "throws exception if file contents cannot be read↵
and assert message"() { 
when: 
fileReader.readContent(Paths.get('hello.text')) 
 
then: 
def t = thrown(IOException) 
t.message == 'File does not exist' 
}
}

View Slide

import org.junit.jupiter.api.RepeatedTest; 
 
public class RepetitionTest { 
 
@RepeatedTest(value = 5, name = "Iteration {currentRepetition}↵
of {totalRepetitions}") 
void canSubstract() { 
assertEquals(1, arithmeticOperation.substract(2, 1)); 
} 
}
Repea2ng test execu2on

View Slide

import spock.lang.Unroll
class RepetitionTest extends Specification { 
@Unroll 
def "Iteration #i of 5"() { 
expect: 
arithmeticOperation.substract(2, 1) == 1 
 
where: 
i << (1..5) 
} 
}
Repea2ng test execu2on

View Slide

import static java.time.Duration.ofSeconds; 
import static org.junit.jupiter.api.Assertions.assertTimeout; 
 
public class TimeoutTest { 
 
@Test 
void canAdd() { 
assertTimeout(ofSeconds(2), () -> { 
}); 
} 
}
Declaring test execu2on 2meouts

View Slide

import spock.lang.Timeout 
 
class TimeoutTest extends Specification { 
 
@Timeout(2) 
def canAdd() { 
expect: 
} 
}
Declaring test execu2on 2meouts

View Slide

Feeding
data to a
scenario

View Slide

import org.junit.jupiter.params.*; 
import java.util.stream.Stream; 
 
public class DataDrivenTest { 
 
@ParameterizedTest(name = "can add {0} to {1} and receive {2}") 
@MethodSource("additionProvider") 
void canAddAndAssertExactResult(int a, int b, int result) { 
assertEquals(result, arithmeticOperation.add(a, b)); 
} 
 
static Stream additionProvider() { 
return Stream.of( 
Arguments.of(1, 3, 4), 
Arguments.of(3, 4, 7) 
); 
} 
}
Data-driven tests

View Slide

Data-driven tests in IntelliJ

View Slide

import spock.lang.Unroll 
 
class DataDrivenTest extends Specification { 
 
@Unroll 
def "can add #a to #b and receive #result"() { 
expect: 
arithmeticOperation.add(a, b) == result 
 
where: 
a | b | result 
1 | 3 | 4 
3 | 4 | 7 
} 
}
Data-driven tests

View Slide

Data-driven tests in IntelliJ

View Slide

Testing
in isolation

View Slide

import static org.mockito.Mockito.mock; 
import static org.mockito.Mockito.when; 
 
public class MockTest { 
... 
 
@Test 
void canMockFileReadOperation() throws IOException { 
String text = "hello"; 
FileReader fileReader = mock(FileReader.class); 
when(fileReader.readContent(testFile)).thenReturn(text); 
FileManager fileManager = new DefaultFileManager(fileReader); 
Files.write(testFile, text.getBytes()); 
assertEquals(text, fileManager.readContent(testFile)); 
} 
}
Mocking dependencies

View Slide

class MockTest extends Specification { 
def fileReader = Mock(FileReader) 
 
def "can mock file read operation"() { 
given: 
def text = "hello" 
Files.write(testFile, text.getBytes()) 
 
when: 
def content = fileManager.readContent(testFile) 
 
then: 
1 * fileReader.readContent(testFile) >> text 
content == text 
} 
}
Mocking dependencies

View Slide

Categorized
test execution

View Slide

import org.junit.jupiter.api.Tag; 
 
public class TaggedTest { 
 
@Tag("slow") 
@Test 
void runsSlowly() { 
} 
 
@Tag("fast") 
@Test 
void runsFast() { 
assertEquals(1, arithmeticOperation.substract(2, 1)); 
} 
}
Labeling and ﬁltering

View Slide

import org.junit.platform.runner.JUnitPlatform; 
import org.junit.platform.suite.api.IncludeTags; 
import org.junit.platform.suite.api.SelectPackages; 
import org.junit.runner.RunWith; 
 
@RunWith(JUnitPlatform.class) 
@SelectPackages("com.bmuschko.test.comparison.junit5.tagged") 
@IncludeTags("fast") 
public class FilteredFastTest { 
}

View Slide

class TaggedTest extends Specification { 
 
@Slow 
def "runs slowly"() { 
expect: 
} 
 
@Fast 
def "runs fast"() { 
expect: 
arithmeticOperation.substract(2, 1) == 1 
} 
}

View Slide

@Retention(RetentionPolicy.RUNTIME) 
@Target([ElementType.TYPE, ElementType.METHOD]) 
@interface Slow { 
} 
 
@Target([ElementType.TYPE, ElementType.METHOD]) 
@interface Fast { 
} 

View Slide

import com.bmuschko.test.comparison.spock.tagged.Fast 
 
runner { 
include Fast 
}
SpockConﬁg.groovy

View Slide

Extending the test framework

View Slide

Third-party extensions
JUnit Pioneer
junit-pioneer.org
Test engines, Docker, Mockito, WireMock and more…
github.com/junit-team/junit5/wiki/Third-party-Extensions

View Slide

Consuming an extension
import org.junit.jupiter.api.extension.ExtendWith; 
 
@ExtendWith(BeforeAfterLoggingExtension.class) 
public class LoggingTest { 
 
@Test 
void canAdd() { 
} 
}

View Slide

Wri2ng a simple extension
import org.junit.jupiter.api.extension.*; 
 
public class BeforeAfterLoggingExtension implements↵
BeforeTestExecutionCallback, AfterTestExecutionCallback { 
@Override 
public void beforeTestExecution(ExtensionContext context) { 
Method testMethod = context.getRequiredTestMethod(); 
System.out.println(String.format("Starting test method %s.%s”,↵
testMethod.getDeclaringClass(), testMethod.getName())); 
} 
 
@Override 
public void afterTestExecution(ExtensionContext context) { 
Method testMethod = context.getRequiredTestMethod(); 
System.out.println(String.format("Finishing test method %s.%s”,↵
testMethod.getDeclaringClass(), testMethod.getName())); 
} 
}

View Slide

Third-party extensions
very liLle out there…

View Slide

Consuming an extension
@BeforeAfterLogging 
class LoggingTest extends Specification { 
 
def "can add"() { 
expect: 
} 
}

View Slide

Wri2ng a simple extension
import org.spockframework.runtime.extension.AbstractAnnotationDrivenExtension 
import org.spockframework.runtime.model.SpecInfo 
 
class BeforeAfterLoggingExtension extends↵
AbstractAnnotationDrivenExtension { 
@Override 
void visitSpecAnnotation(BeforeAfterLogging annotation, SpecInfo spec) { 
spec.addListener(new BeforeAfterEventListener()) 
} 
}
import org.spockframework.runtime.extension.ExtensionAnnotation 
 
@Target(ElementType.TYPE) 
@ExtensionAnnotation(BeforeAfterLoggingExtension.class) 
@interface BeforeAfterLogging { 
}

View Slide

“Which framework is beLer?”

View Slide

Accommodate your team’s skill set

View Slide

Tests as readable user stories

View Slide

Which features are crucial to you?

View Slide

Resources
junit.org/junit5
spockframework.org
bmuschko.com/blog/junit5-vs-spock-showdown
github.com/bmuschko/junit5-vs-spock-feature-comparison

View Slide

Thanks!
Please ask ques2ons.

View Slide

Getting the most out of your next generation JVM testing framework

Getting the most out of your next generation JVM testing framework

Benjamin Muschko

More Decks by Benjamin Muschko

Other Decks in Programming

Featured

Transcript