So last time we looked at how to use Slick to connect to a SQL server database.
This time we look at how to use one of the 2 popular Scala testing frameworks.
The 2 big names when it comes to Scala testing are
- ScalaTest
- Specs2
I have chosen to use ScalaTest as it seems slightly more popular, when you do a Google search, and I quite liked the syntax. That said Specs2 is also very good. so if you fancy having a look at that you should.
SBT for ScalaTest
So what do we need to get started with ScalaTest. As always we need to grab the JAR, which we do using SBT.
At time of writing this was accomplished using this SBT entry:
name := "ClassesDemo" version := "1.0" scalaVersion := "2.11.7" libraryDependencies ++= Seq( "org.scalatest" %% "scalatest" % "2.2.5" % "test" )
With that in place, SBT should pull down the JAR from Maven Central for you. So once you are happy that you have the ScalaTest JAR installed, we can not proceed to write some tests.
Writing Some Tests
I come from a .NET background, and as such I am using to working with tools such as
- NUnit
- TestFixture
- Setup : To setup the test
- TearDown : To teardown the test
- Moq / FakeItEasy : Mocking frameworks
As such I wanted to make sure I could do everything that I was used to in .NET using ScalaTest.
This article will concentrate on the testing side of things, while the next post will be on the mocking side of things.
So let’s carry on for now shall we.
Choosing You Test Style
ScalaTest allows you to use 2 different styles of writing tests.
- FunSuite : This is more in line with what you get with NUnit say. We would write something like Test(“testing should be easy”)
- FlatSpec : This is more of a BDD style test declaration, where we would write something like this: “Testing” should “be easy”
We will see an examples of both of these styles in just a minute, but before that lets carry on and looks at some of the common things you may want to do with your tests
Setup / TearDown
You may want to run some startup/teardown code that is run. Typically startup would be used to setup mocks for your test cases, and that sort of thing.
In things like NUnit this would simply be done by creating a method and attributing it to say it is the Setup/TearDown methods.
In ScalaTest things are slightly different in that we need to mixin the “BeforeAndAfter” trait to do this. Lets see an example:
import org.scalatest.{FunSuite, BeforeAndAfter}
import scala.collection.mutable.ListBuffer
class FunSuite_Example_Tests extends FunSuite with BeforeAndAfter {
val builder = new StringBuilder
val buffer = new ListBuffer[String]
before {
builder.append("ScalaTest is ")
}
after {
builder.clear()
buffer.clear()
}
}
It can be seen in this example that the BeforeAndAfter trait, gives you 2 additional functions
- before
- after
You can use these to perform your startup/teardown logic.
This example uses the FunSuite style, but the “BeforeAndAfter” trait mixin is done exactly the same for the FlatSpec style testing.
Writing A Test Using FunSuite
I think if you have come from a NUnit / XUnit type of background you will probably identify more with the FunSuite style of testing.
Here is an example of a set of FunSuite tests.
import org.scalatest.{FunSuite, BeforeAndAfter}
import scala.collection.mutable.ListBuffer
class FunSuite_Example_Tests extends FunSuite with BeforeAndAfter {
val builder = new StringBuilder
val buffer = new ListBuffer[String]
before {
builder.append("ScalaTest is ")
}
after {
builder.clear()
buffer.clear()
}
test("Testing should be easy") {
builder.append("easy!")
assert(builder.toString === "ScalaTest is easy!")
assert(buffer.isEmpty)
buffer += "sweet"
}
test("Testing should be fun") {
builder.append("fun!")
assert(builder.toString === "ScalaTest is fun!")
assert(buffer.isEmpty)
}
}
It can be see that they follow the very tried and tested approach of tools like NUnit, where you have a test(…) function, where “…” is the text that describes your testcase.
Nothing much more to say there apart from to make sure you mixin the FunSuite trait.
Writing A Test Using FlatSpec
ScalaTest also supports another way of writing your tests, which is to use the FlatSpec trait, which you would mixin instead of the FunSuite trait.
When you use FlatSpec you would be writing your tests more like this:
- “Testing” should “be easy” in {…}
- it should “be fun” in {…}
Its more of a BDD style way of creating your test cases.
Here is the exact same test suite that we saw above but this time written using the FlatSpec instead of FunSuite.
import scala.collection.mutable.ListBuffer
class FlatSpec_Example_Tests extends FlatSpec with BeforeAndAfter {
val builder = new StringBuilder
val buffer = new ListBuffer[String]
before {
builder.append("ScalaTest is ")
}
after {
builder.clear()
buffer.clear()
}
"Testing" should "be easy" in {
builder.append("easy!")
assert(builder.toString === "ScalaTest is easy!")
assert(buffer.isEmpty)
buffer += "sweet"
}
it should "be fun" in {
builder.append("fun!")
assert(builder.toString === "ScalaTest is fun!")
assert(buffer.isEmpty)
}
}
I don’t mind either, I guess it’s down to personal choice/taste at the end of the day.
Using Matchers
Matchers are ScalaTest’s way of providing additonal constraints to assert against. In some testing frameworks we would just use the Assert class for that along with things like
- Assert.AreEqual(..)
- Assert.IsNotNull(..)
In ScalaTest you can still use the assert(..) function, but matchers are also a good way of expressing your test conditional.
So what exactly are matchers?
In the words of the ScalaTest creators:
ScalaTest provides a domain specific language (DSL) for expressing assertions in tests using the word should.
So what do we need to do to use these ScalaTest matchers? Well quite simply we need to just mix in Matchers, like this:
import org.scalatest._
class ExampleSpec extends FlatSpec with Matchers { ...}
You can alternatively import the members of the trait, a technique particularly useful when you want to try out matcher expressions in the Scala interpeter. Here’s an example where the members of Matchers are imported:
import org.scalatest._
import Matchers._
class ExampleSpec extends FlatSpec { // Can use matchers here ...
So that give us the ability to use the ScalaTest matchers DSL. So what do these things look like. Lets see a couple of examples:
import org.scalatest._
class FlatSpec_Example_Tests extends FlatSpec with Matchers {
"Testing" should "probably use some matchers" in {
//equality examples
Array(1, 2) should equal (Array(1, 2))
val resultInt = 23
resultInt should equal (3) // can customize equality
resultInt should === (3) // can customize equality and enforce type constraints
resultInt should be (3) // cannot customize equality, so fastest to compile
resultInt shouldEqual 3 // can customize equality, no parentheses required
resultInt shouldBe 3 // cannot customize equality, so fastest to compile, no parentheses required
//length examples
List(1,2) should have length 2
"cat" should have length 3
//string examples
val helloWorld = "Hello worlld"
helloWorld should startWith ("Hello")
helloWorld should endWith ("world")
val sevenString ="six seven eight"
sevenString should include ("seven")
//greater than / less than
val one = 1
val zero = 0
val seven = 7
one should be < seven
one should be > zero
one should be <= seven
one should be >= zero
//emptiness
List() shouldBe empty
List(1,2) should not be empty
}
}
For more information on using matchers, you should consult this documentation, which you can find here:
http://www.scalatest.org/user_guide/using_matchers
Sacha's Blog 