CODEWITHSUNDEEP
scalatestingspecs2scala-2.11spec2
shodz
shodz

Reputation: 384

scala spec2 I am Unable to create a test that uses must be_== and failure at the same time

I am new to Scala and Spec2.

I would like to create the following test but I get an error from the compiler.

Here is the test I would like to write

import org.specs2.mutable._
import org.specs2.specification._
import org.specs2.matcher._
import org.specs2.matcher.MatchResult

class SimpleParserSpec extends Specification {

"SimpleParser" should {

val parser = new SimpleParser()

  "work with basic tweet" in {
      val tweet = """{"id":1,"text":"foo"}"""
      parser.parse(tweet) match {
        case Some(parsed) => {
                                parsed.text must be_==("foo")
                                parsed.id must be_==(1)
                              }
        case _ =>  failure("didn't parse tweet") 
      }
    }
  }
}

I get the error: C:\Users\haques\Documents\workspace\SBT\jsonParser\src\test\scala\com\twitter\sample\simpleSimpleParserSpec.scala:17: could not find implicit value for evidence parameter of type org.specs2.execute.AsResult[Object]

Regards,

Shohidul

Upvotes: 8

Views: 2434

Answers (3)

Eric
Eric

Reputation: 15557

The compiler produces an error here because he tries to unify a MatchResult[Option[Parsed]] with a failure of type Result. They unify as Object and the compiler can't find an AsResult typeclass instance for that. You can fix your example by providing another MatchResult for the failed case:

parser.parse(tweet) match {
  case Some(parsed) => {
    parsed.text must be_==("foo")
    parsed.id must be_==(1)
  }
  case _ =>  ko("didn't parse tweet")
}

The ok and ko methods are the equivalent of success and failure but are MatchResults instead of being Results.

Upvotes: 10

redeagle47
redeagle47

Reputation: 1367

one thing you could try would be to make SimpleParser a trait. This has usually worked better for me when using Specs2. Then you could call parse(tweet). I would also suggest breaking up the tests a little. 

class SimpleParserSpec extends Specification with SimpleParser { 
     val tweet = """{"id":1,"text":"foo"}"""
     SimpleParser should {
        "parse out the id" in {
              val parsedTweet = parse(tweet)
              parsedTweet.id === 1
         }
}

From here you could add in the other fields that you wanted to test.

EDIT: Looking back at what I wrote, I see I didn't completely answer what you were asking. you could put the === and then failure into cases like you already had, but within the framework of what I have.

Upvotes: 0

cchantep
cchantep

Reputation: 9158

Would better write it as following:

"work with basic tweet" in {
  val tweet = """{"id":1,"text":"foo"}"""
  parser.parse(tweet) aka "parsed value" must beSome.which {
    case parsed => parsed.text must_== "foo" and (
      parsed.id must_== 1)
  }
}

Upvotes: 2

Related Questions