Testing in Scala by Adform research

1. Testing in Scala

2. Concepts: Types of Tests
Technology
Business
GlobalLocal
Unit Integration
Functional
Acceptance

3. Unit Tests
• Check very specific functionality of your code
• Assumes everything else works (mocking)
• Test one specific/technical thing
• e.g. test your Hadoop job locally, given money in DKK, currency
conversion to EUR is called once

4. Integration Tests
• Check that all components work together
• Includes real components, databases, files, etc.
• Test the connectivity of components
• e.g. run a job on a development Hadoop cluster, given sample data
expected output is written

5. Functional Tests
• Test your product against the functionality you developed
• Use real components, real data
• E.g. run job on a live cluster, given a days worth of data the output is
correct (as expected according to specification)

6. Acceptance Tests
• Final tests performed by your client before “accepting the product”
• Real components, real data, output is correct, performance is
acceptable, client is happy

7. Concepts: Testing Styles
• TDD: Test Driven Development
• BDD: Behavior Driven Development

8. Test Driven Development
• Write an interface (trait) for the behavior
• Write an empty implementation
• Write your unit tests
• Make the code compile and tests fail
• Correct the implementation
• Make the tests pass !

9. Behavior Driven Development
• Same idea, just write more functional tests (define behavior)

10. Testing in Scala
• For every class in src/main/scala write a test class in src/test/scala
• Test classes ~ Test suites
• Methods ~ Tests
• Run the suit and see the output

11. Testing Libraries/Frameworks
• Java: JUnit, TestNG (can be used with scala)
• Scala: ScalaTest, Specs2
• Mocking: ScalaMock, EasyMock, JMock, Mockito
• Property Testing: ScalaCheck
• UI Testing: Selenium

12. • Very similar to Specs2, maybe more flexible, mainly choice of taste
• Integrates with sbt, IntelliJ
• Integrates with Mockito, ScalaCheck
libraryDependencies += "org.scalatest" %% "scalatest" % "2.2.1" % "test"

13. Using ScalaTest
import org.scalatest.FunSuite
class SetSuite extends FunSuite {
test("An empty Set should have size 0") {
assert(Set.empty.size == 0)
}
test("Invoking head on an empty Set should produce NoSuchElementException") {
intercept[NoSuchElementException] {
Set.empty.head
}
}
}

17. Style Traits
• ScalaTest allows you to mix in a testing style you like:
• FunSuite
• FlatSpec
• FunSpec
• WordSpec
• PropSpec
• etc.
• http://www.scalatest.org/user_guide/selecting_a_style

18. FunSuite

19. FlatSpec

20. WordSpec

21. FeatureSpec

22. Testing Styles
• ScalaTest recommends having an abstract class with the specs and
other traits you like
package com.mycompany.myproject
import org.scalatest._
abstract class UnitSpec extends FlatSpec with Matchers with OptionValues with Inside with Inspectors
package com.mycompany.myproject
import org.scalatest._
class MySpec extends UnitSpec {
// Your tests here
}

23. Fixtures
• Your tests may need some setting up and tearing down
• ScalaTest has many ways of doing this
• http://www.scalatest.org/user_guide/sharing_fixtures

25. Matchers
• ScalaTest has lots of syntactic sugar to express your desires
result should equal (3)
result should have size 10
string should fullyMatch regex """(-)?(d+)(.d*)?"""
result1 should not be an [Orangutan]
sevenDotOh should equal (6.9 +- 0.2)
"howdy" should contain oneOf ('a', 'b', 'c', 'd')
(Array("Doe", "Ray", "Me") should contain oneOf ("X", "RAY", "BEAM")) (after being lowerCased)
List(0, 1, 2, 2, 99, 3, 3, 3, 5) should contain inOrder (1, 2, 3)
map should (contain key ("two") and not contain value (7))
This is Scala Code !!

26. Mocking
• You should always code against interfaces (traits)
• If you do, testing is easier, since you can mock your dependencies!
val m = mock[Turtle]
m.expects.forward(10.0) twice
m1 returns 42
m2 expects ("this", "that") returning "the other"

27. Property Based Testing
• New and exciting way of testing your code!
• Instead of examples, you specify properties (higher order testing!)
• E.g. when you concatenate two lists, new lengths is sum of lengths
• ScalaCheck then generates random inputs and runs many tests
• This can catch MANY corner cases you never expect!

28. ScalaCheck
import org.scalacheck.Gen
val propConcatLists = forAll { (l1: List[Int], l2: List[Int]) =>
l1.size + l2.size == (l1 ::: l2).size
}
+ OK, passed 100 tests.
val propSqrt = forAll { (n: Int) => scala.math.sqrt(n*n) == n }
! Falsified after 1 passed tests:
> -1

29. ScalaCheck: Generators
val genLeaf = value(Leaf)
val genNode = for {
v <- arbitrary[Int]
left <- genTree
right <- genTree
} yield Node(left, right, v)
def genTree: Gen[Tree] = oneOf(genLeaf, genNode)
Option[Tree] = Some(Node(Leaf,Node(Node(Node(Node(Node(Node(Leaf,Leaf,-
71),Node(Leaf,Leaf,-49),17),Leaf,-20),Leaf,-7),Node(Node(Leaf,Leaf,26),Leaf,-
3),49),Leaf,84),-29))

30. is
AWESOME !!

31. Scoverage
• Produces test coverage reports
• Measures how many statements are tested
• Only works with Scala 2.11

33. Testing Scalding Jobs
HOMEWORK: use ScalaTest instead of Specs2

34. DEMO TIME
Slava takes the stage