Daily scala

This topic revisits the Specs BDD testing library. It is a continuation of the previous post Specs BDD Testing Framework.

This topic will look at how to setup fixtures in Specs. This is only a sample to give a feeling of Specs a much more complete guide is available on the Specs website.

1. jeichar: git-src$ scala -classpath ~/.m2/repository/org/scala-tools/testing/specs/1.6.1/specs-1.6.1.jar
2. scala> import org.specs._
3. import org.specs._
4. /*
5. This example demonstrates before and after actions similar to what is found in XUnit.
6. */
7. scala> object mySpec extends Specification {           
8.      | "my system" should {
9.      | doFirst{println("before")}  // ran once
10.      | 
11.      | doBefore{println("before")} // ran for each test
12.      | doAfter{println("after")} // ran for each test
13.      | 
14.      | "test spec 1" in { println("test1"); 1 must_== 1}
15.      | "test spec 2" in { println("test2"); 1 must_== 2}
16.      | 
17.      | doLast{println("last")} // ran once
18.      | }}
19. defined module mySpec
20. scala> mySpec.main(Array())                             
21. Specification "mySpec"
22.   my system should
23. before
24. before
25. test1
26. after
27.   + test spec 1
28. before
29. test2
30. after
31. last
32.   x test spec 2
33.     '1' is not equal to '2' (< console>:14)
34. Total for specification "mySpec":
35. Finished in 0 second, 307 ms
36. 2 examples, 2 expectations, 1 failure, 0 error

Example using Contexts there many more examples at: Shared contexts

1. scala> import org.specs._
2. import org.specs._
3. /*
4. This specification uses contexts instead of before and after actions.
6. My personal preference is to use contexts because they are more flexible and can have names associated with them.  In addition contexts can be shared between specifications and multiple contexts can be used within a single specification.  This example is kept very simple for demonstration purposes
7. */
8. scala> object StackSpecification extends Specification {
9.      |   var list : List[Int] = _
10.      |   val empty = beforeContext(list = Nil)  
11.      |   val nonEmpty = beforeContext(list = List(1,2,3))
12.      |   
13.      |   "A full stack" definedAs nonEmpty should { 
14.      |     "size of 3" in {
15.      |       list must haveSize (3)
16.      |     }
17.      |   }
18.      |   "A stack" when empty should { 
19.      |     "is empty" in {
20.      |       list must beEmpty
21.      |     }
22.      |   }
23.      | }
24. defined module StackSpecification
25. scala> StackSpecification.main(Array())
26. Specification "StackSpecification"
27.   A full stack should
28.   + size of 3
29.   Total for SUS "A full stack":
30.   Finished in 0 second, 42 ms
31.   1 example, 1 expectation, 0 failure, 0 error
32.   A stack should
33.   + is empty
34.   Total for SUS "A stack":
35.   Finished in 0 second, 4 ms
36.   1 example, 1 expectation, 0 failure, 0 error
37. Total for specification "StackSpecification":
38. Finished in 0 second, 85 ms
39. 2 examples, 2 expectations, 0 failure, 0 error

This is the second Scala test framework topic and focuses on the excellent Specs framework. The other topic was on ScalaTest, another excellent testing framework for Scala.

Specs is focussed on BDD testing (Behaviour Driven Design) and is the inspiration for ScalaTests WordSpec. From what I understand Specs was in-turn inspired by RSpec the Ruby BDD testing framework.

Specs has some truly unique features to it which we will encounter in future topics. But for now just the basics. The following example tests a couple of Scala's XML support in order to demonstract the general pattern followed when writing Specs' tests.

1. # scala -classpath ~/.m2/repository/org/scala-tools/testing/specs/1.6.1/specs-1.6.1.jar
2. scala> import org.specs._
3. import org.specs._
4. scala> object XmlSpec extends Specification {
5.      |  val sample = <library>
6.      |         <videos>
7.      |         <video type="dvd">Seven</video>
8.      |         <video type="blue-ray">The fifth element</video>
9.      |         <video type="hardcover">Gardens of the moon</video>
10.      |         </videos>
11.      |         <books>
12.      |         <book type="softcover">Memories of Ice</book>
13.      |         </books>
14.      |         </library>
15.      |  "Scala XML" should {
16.      |   "allow xpath-like selection" in {
17.      |    (sample \\ "video").size must be (3)    
18.      |   }
19.      |   "select child nodes" in {
20.      |    // This test fails because child is a sequence not a string
21.      |    // See the results of the tests
22.      |    sample.child must contain (<videos/>)
23.      |   }
24.      |  }
25.      |  }
26. defined module XmlSpec
27. scala> XmlSpec.main(Array[String]())
28. Specification "XmlSpec"
29.   Scala XML should
30.   + allow xpath-like selection
31.   x select child nodes <-- x indicates failure.
32.     'ArrayBuffer(
33.                    , <videos>
34.                    <video type="dvd">Seven</video>
35.                    <video type="blue-ray">The fifth element</video>
36.                    <video type="hardcover">Gardens of the moon</video>
37.                    </videos>, 
38.                    , <books>
39.                    <book type="softcover">Memories of Ice</book>
40.                    </books>, 
41.                    )' doesn't contain '<videos></videos>' (< console>:24)
42. Total for specification "XmlSpec":
43. Finished in 0 second, 52 ms
44. 2 examples, 2 expectations, 1 failure, 0 error

This is the first of three topics exploring some of the testing tools that you can use with Scala. They all integrate with JUnit and can be used with maven and ant.

The first example is ScalaTest. ScalaTest provides many different usage patterns but the one I will show today is a Behaviour Driven Design test. It provides a DSL for declaring a test that is nearly english in syntax and if done correctly can be given to a non technical person to review. The ScalaTest BDD test style was inspired by the work done on Specs by Eric Torreborre. I will demonstrate that library in the next topic.

I want to reiterate that ScalaTest permits several different styles of test writing. NUnit, JUnit and BDD are the main styles. So anyone that is used to NUnit or JUnit should have no problem using ScalaTest but if you like the look of the BDD test specifications then you can migrate and slowly become accustomed to that style.

If you want to integrate with JUnit one easy way to add the @RunWith annotation for the class. See JUnitRunner for details:

1. import org.scalatest.junit.JUnitRunner
2. import org.junit.runner.RunWith
3. @RunWith(classOf[JUnitRunner])
4. class StackSpec extends WordSpec {
5. ...
6. }

Instructions to run example:

1. Download ScalaTest: http://www.scalatest.org/download
2. Extract archive. For example to /tmp/
3. Run scala with the ScalaTest jar on classpath: scala -classpath /tmp/scalatest-1.0/scalatest-1.0.jar
4. copy in code

This example is directly taken from the ScalaTest documentation. It tests a Stack implementation.

1. scala>  import org.scalatest.WordSpec
2. import org.scalatest.WordSpec
3. scala>  import scala.collection.mutable.Stack
4. import scala.collection.mutable.Stack
5. scala> 
6. scala>  class StackSpec extends WordSpec {
7.      | 
8.      |    "A Stack" should {
9.      | 
10.      |      "pop values in last-in-first-out order" in {
11.      |        val stack = new Stack[Int]
12.      |        stack.push(1)
13.      |        stack.push(2)
14.      |        assert(stack.pop() === 2)
15.      |        assert(stack.pop() === 1)
16.      |      }
17.      | 
18.      |      "throw NoSuchElementException if an empty stack is popped" in {
19.      |        val emptyStack = new Stack[String]
20.      |        intercept[NoSuchElementException] {
21.      |          emptyStack.pop()
22.      |        }
23.      |      }
24.      |    }
25.      |  }
26. defined class StackSpec
27. scala> new StackSpec().execute()
28. A Stack 
29. - should pop values in last-in-first-out order
30. - should throw NoSuchElementException if an empty stack is popped