Scala - JUnit Testing

Previous
Quiz

JUnit is a testing framework for Java applications. It is used to write and run repeatable automated tests for correctness of your code. You can use JUnit for testing Scala applications. There are various features and integration capabilities within Scala projects.

You can write unit tests and integration tests using JUnit. You can also test performance to validate the behavior and performance of your application.

JUnit 4 with Scala

Dependencies

You need to add the following dependency to your build.sbt file to use JUnit 4 in a Scala project -

 libraryDependencies += "com.github.sbt" % "junit-interface" % "0.13.3" % "test"

Now, you can run JUnit tests from SBT.

Writing and Running Tests

Consider this example for a simple JUnit 4 test in Scala -

 package com.example.scala import org.junit.Test import org.junit.Assert._ class IntJunitTests { @Test def testOneIsPositive(): Unit = { assertTrue(1 > 0) } @Test def testMinusOneIsNegative(): Unit = { assertTrue(-1 < 0) } }

You can use the test command to run the tests from the sbt shell -

 sbt test

The output will be,

 [info] Passed: Total 2, Failed 0, Errors 0, Passed 2 [success] Total time: 3 s, completed 08-Aug-2024, 11:45:48 am

Advanced Test Execution

You can also run specific tests using commands like testOnly -

 sbt "testOnly com.example.scala.IntJunitTests"

The output will be,

 [info] Passed: Total 2, Failed 0, Errors 0, Passed 2 [success] Total time: 0 s, completed 08-Aug-2024, 11:46:47 am

You can run a single test within a class -

 sbt "testOnly -- *.IntJunitTests.testOneIsPositive"

The output will be,

 [info] Passed: Total 1, Failed 0, Errors 0, Passed 1 [success] Total time: 0 s, completed 08-Aug-2024, 11:47:29 am

Test Suites

JUnit also supports test suites. You can group multiple test classes. For example,

 package com.example.scala import org.junit.runner.RunWith import org.junit.runners.Suite @RunWith(classOf[Suite]) @Suite.SuiteClasses(Array(classOf[IntJunitTests], classOf[StringJunitTests])) class TypesTestSuite

You can run the test suite -

 sbt "testOnly *.TypesTestSuite"

Custom Test Runner

Sometimes, you may need to customize the test runner to handle specific test execution requirements. You can create custom test runner, like this -

 import org.junit.runner.RunWith import org.scalatestplus.junit.JUnitRunner @RunWith(classOf[JUnitRunner]) class CustomTestRunner extends JUnitSuite { // Custom test logic here }

JUnit 5 with Scala

Dependencies and Setup

JUnit 5 requires a different setup compared to JUnit 4. You need to add the following to your plugins.sbt -

 resolvers += Resolver.jcenterRepo addSbtPlugin("net.aichler" % "sbt-jupiter-interface" % "0.8.3")

Now, you should have this following dependency in your build.sbt -

 libraryDependencies += "net.aichler" % "jupiter-interface" % "0.8.3" % Test

Writing JUnit 5 Tests

Consider this example of using JUnit 5 in Scala -

 package com.example.scala import org.junit.jupiter.api.Disabled import org.junit.jupiter.api.Test class ExampleTests { @Disabled("Not implemented yet") @Test def testNotImplemented(): Unit = {} }

Now, you can run the tests using -

 sbt test

The output will be,

 [success] Total time: 3 s, completed 08-Aug-2024, 11:52:25 am

Test Lifecycle Management

JUnit 5 provides annotations for managing the lifecycle of tests, like, @BeforeAll, @AfterAll, @BeforeEach, and @AfterEach. Here is how you can use these in Scala -

 package com.example.scala import org.junit.jupiter.api.{BeforeAll, AfterAll, BeforeEach, AfterEach, TestInstance, Test} import org.junit.jupiter.api.TestInstance.Lifecycle @TestInstance(Lifecycle.PER_CLASS) class LifecycleTests { @BeforeAll def beforeAll(): Unit = { println("Before all tests") } @AfterAll def afterAll(): Unit = { println("After all tests") } @BeforeEach def beforeEach(): Unit = { println("Before each test") } @AfterEach def afterEach(): Unit = { println("After each test") } @Test def testExample(): Unit = { println("Executing test") } }

Note that you should have these dependencies in your build.sbt file -

 scalaVersion := "2.13.14" libraryDependencies ++= Seq( "org.junit.jupiter" % "junit-jupiter-api" % "5.8.1" % "test", "org.junit.jupiter" % "junit-jupiter-engine" % "5.8.1" % "test", "org.junit.platform" % "junit-platform-launcher" % "1.8.1" % "test" ) testFrameworks += new TestFramework("munit.Framework")

Now, you can compile and run test using these commands -

 sbt clean compile sbt run

The output will be,

 [success] Total time: 3 s, completed 08-Aug-2024, 12:00:04 pm

ScalaTest Integration

Using ScalaTest with JUnit

ScalaTest provides more readable and concise assertions. You can use ScalaTest assertions with JUnit, mix in AssertionsForJUnit. For example,

 package com.example.scala import org.scalatestplus.junit.AssertionsForJUnit import org.junit.Assert._ import org.junit.Test class ExampleSuite extends AssertionsForJUnit { @Test def verifyEasy(): Unit = { assertEquals("ScalaTest is easy!", "ScalaTest is easy!") } @Test def verifyFun(): Unit = { assert("ScalaTest is fun!" == "ScalaTest is fun!") } }

You need to add the following dependencies to your build.sbt -

 import Dependencies._ ThisBuild / scalaVersion := "2.13.14" lazy val root = (project in file(".")) .settings( name := "Demo", version := "0.1", libraryDependencies ++= Seq( "org.scalatest" %% "scalatest" % "3.2.12" % "test", "com.github.sbt" % "junit-interface" % "0.13.3" % "test", "org.scalatestplus" %% "junit-4-12" % "3.2.2.0" % "test" ) )

The output will be,

 [info] Passed: Total 2, Failed 0, Errors 0, Passed 2 [success] Total time: 1 s, completed 08-Aug-2024, 2:14:31 pm

Combining ScalaTest and JUnit

You can write tests that can be run by both JUnit and ScalaTest. For example,

 import org.scalatestplus.junit.JUnitSuite import org.junit.Assert._ import org.junit.Test import org.junit.Before class CombinedSuite extends JUnitSuite { var sb: StringBuilder = _ var lb: ListBuffer[String] = _ @Before def initialize(): Unit = { sb = new StringBuilder("ScalaTest is ") lb = new ListBuffer[String] } @Test def verifyEasy(): Unit = { sb.append("easy!") assertEquals("ScalaTest is easy!", sb.toString) assertTrue(lb.isEmpty) lb += "sweet" try { "verbose".charAt(-1) fail() } catch { case e: StringIndexOutOfBoundsException => // Expected } } @Test def verifyFun(): Unit = { sb.append("fun!") assert(sb.toString === "ScalaTest is fun!") assert(lb.isEmpty) lb += "sweeter" intercept[StringIndexOutOfBoundsException] { "concise".charAt(-1) } } }

So, there can be flexibility in using either test framework.

Example: Testing a Calculator

Consider this test a simple calculator application -

 package com.example.scala import org.junit.Test import org.junit.Assert._ class CalculatorTests { class Calculator { def add(a: Int, b: Int): Int = a + b def subtract(a: Int, b: Int): Int = a - b def multiply(a: Int, b: Int): Int = a * b def divide(a: Int, b: Int): Int = if (b != 0) a / b else throw new ArithmeticException("Division by zero") } val calculator = new Calculator @Test def testAddition(): Unit = { assertEquals(5, calculator.add(2, 3)) } @Test def testSubtraction(): Unit = { assertEquals(1, calculator.subtract(3, 2)) } @Test def testMultiplication(): Unit = { assertEquals(6, calculator.multiply(2, 3)) } @Test(expected = classOf[ArithmeticException]) def testDivisionByZero(): Unit = { calculator.divide(1, 0) } @Test def testDivision(): Unit = { assertEquals(2, calculator.divide(6, 3)) } }

Example: Testing a Simple Scala Class

Consider this example of testing a simple Scala class -

 package com.example.scala import org.junit.Test import org.junit.Assert._ class Person(val name: String, val age: Int) class PersonTests { @Test def testPersonCreation(): Unit = { val person = new Person("John Doe", 30) assertEquals("John Doe", person.name) assertEquals(30, person.age) } @Test def testPersonAge(): Unit = { val person = new Person("Jane Doe", 25) assertTrue(person.age > 20) } }
Print Page
Previous
Next
Advertisements