org.scalatest.words.HaveWord.scala Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of scalatest_2.11.0-RC2 Show documentation
ScalaTest is a free, open-source testing toolkit for Scala and Java programmers.
The newest version!
/*
 * Copyright 2001-2013 Artima, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.scalatest.words

import org.scalatest.matchers._
import org.scalatest.enablers._
import org.scalautils._
import org.scalatest.FailureMessages
import org.scalatest.UnquotedString
import org.scalatest.Resources
import scala.collection.GenTraversable
import scala.collection.GenSeq
import org.scalatest.MatchersHelper.accessProperty

/**
 * This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of
 * the matchers DSL.
 *
 * @author Bill Venners
 */
final class HaveWord {

  /**
   * This method enables the following syntax:
   *
   *    * book should have length (9)
   *                  ^
   * 
   */
  def length(expectedLength: Long): MatcherFactory1[Any, Length] =
    new MatcherFactory1[Any, Length] {
      def matcher[T <: Any : Length]: Matcher[T] = {
        val length = implicitly[Length[T]]
        new Matcher[T] {
          def apply(left: T): MatchResult = {
            val lengthOfLeft = length.lengthOf(left)
            MatchResult(
              lengthOfLeft == expectedLength,
              Resources("hadLengthInsteadOfExpectedLength"),
              Resources("hadLength"), 
              Vector(left, lengthOfLeft, expectedLength), 
              Vector(left, expectedLength)
            )
          }
          override def toString: String = "have length " + expectedLength
        }
      }
      override def toString: String = "have length " + expectedLength
    }

  /**
   * This method enables the following syntax:
   *
   *    * book should have size (9)
   *                  ^
   * 
   *
   * 
   * Currently, this method will produce a Matcher[AnyRef], and if the
   * AnyRef passed to that matcher's apply method does not have the appropriate size property
   * structure, all will compile but a TestFailedException will result at runtime explaining the problem.
   * In a future ScalaTest release, this may be tightened so that all is statically checked at compile time.
   * 
   */
  def size(expectedSize: Long): MatcherFactory1[Any, Size] =
    new MatcherFactory1[Any, Size] {
      def matcher[T <: Any : Size]: Matcher[T] = {
        val size = implicitly[Size[T]]
        new Matcher[T] {
          def apply(left: T): MatchResult = {
            val sizeOfLeft = size.sizeOf(left)
            MatchResult(
              sizeOfLeft == expectedSize,
              FailureMessages("hadSizeInsteadOfExpectedSize"),
              FailureMessages("hadSize"), 
              Vector(left, sizeOfLeft, expectedSize), 
              Vector(left, expectedSize)
            )
          }
          override def toString: String = "have size " + expectedSize
        }
      }
      override def toString: String = "have size " + expectedSize
    }
  
  /**
   * This method enables the following syntax:
   *
   *    * result should have message ("A message from Mars!")
   *                    ^
   * 
   */
  def message(expectedMessage: String): MatcherFactory1[Any, Messaging] =
    new MatcherFactory1[Any, Messaging] {
      def matcher[T <: Any : Messaging]: Matcher[T] = {
        val messaging = implicitly[Messaging[T]]
        new Matcher[T] {
          def apply(left: T): MatchResult = {
            val messageOfLeft = messaging.messageOf(left)
            MatchResult(
              messageOfLeft == expectedMessage,
              FailureMessages("hadMessageInsteadOfExpectedMessage"),
              FailureMessages("hadExpectedMessage"), 
              Vector(left, messageOfLeft, expectedMessage), 
              Vector(left, expectedMessage)
            )
          }
          override def toString: String = "have message " + Prettifier.default(expectedMessage)
        }
      }
      override def toString: String = "have message " + Prettifier.default(expectedMessage)
    }

  /**
   * Enables parentheses to be placed around length (N) in expressions of the form: should have (length (N)).
   */
  def apply[T](resultOfLengthWordApplication: ResultOfLengthWordApplication): MatcherFactory1[Any, Length] = length(resultOfLengthWordApplication.expectedLength)


  /**
   * Enables parentheses to be placed around size (N) in expressions of the form: should have (size (N)).
   */
  def apply[T](resultOfSizeWordApplication: ResultOfSizeWordApplication): MatcherFactory1[Any, Size] = size(resultOfSizeWordApplication.expectedSize)

  /**
   * This method enables the following syntax:
   *
   *    * book should have (title ("A Tale of Two Cities"))
   *                  ^
   * 
   */
  def apply[T](firstPropertyMatcher: HavePropertyMatcher[T, _], propertyMatchers: HavePropertyMatcher[T, _]*): Matcher[T] =

    new Matcher[T] {

      def apply(left: T): MatchResult = {

        val results =
          for (propertyVerifier <- firstPropertyMatcher :: propertyMatchers.toList) yield
            propertyVerifier(left)

        val firstFailureOption = results.find(pv => !pv.matches)

        val justOneProperty = propertyMatchers.length == 0

        firstFailureOption match {

          case Some(firstFailure) =>

            val failedVerification = firstFailure
            val (rawFailureMessage, failureMessageArgs) =
              (
                Resources("propertyDidNotHaveExpectedValue"), 
                Vector(
                  UnquotedString(failedVerification.propertyName),
                  failedVerification.expectedValue,
                  failedVerification.actualValue,
                  left  
                )
              )
            val (rawMidSentenceFailureMessage, midSentenceFailureMessageArgs) =
              (
                Resources("midSentencePropertyDidNotHaveExpectedValue"), 
                Vector(
                  UnquotedString(failedVerification.propertyName),
                  failedVerification.expectedValue,
                  failedVerification.actualValue,
                  left  
                )
              )

            MatchResult(false, rawFailureMessage, rawFailureMessage, rawMidSentenceFailureMessage, rawMidSentenceFailureMessage, failureMessageArgs, midSentenceFailureMessageArgs)

          case None =>

            val (rawFailureMessage, failureMessageArgs) =
              if (justOneProperty) {
                val firstPropertyResult = results.head // know this will succeed, because firstPropertyMatcher was required
                (
                  Resources("propertyHadExpectedValue"), 
                  Vector(
                    UnquotedString(firstPropertyResult.propertyName),
                    firstPropertyResult.expectedValue,
                    left  
                  )
                )
              }
              else (Resources("allPropertiesHadExpectedValues"), Vector(left))

            val (rawMidSentenceFailureMessage, rawMidSentenceFailureMessageArgs) =
              if (justOneProperty) {
                val firstPropertyResult = results.head // know this will succeed, because firstPropertyMatcher was required
                (
                  Resources("midSentencePropertyHadExpectedValue"), 
                  Vector(
                    UnquotedString(firstPropertyResult.propertyName),
                    firstPropertyResult.expectedValue,
                    left    
                  )
                )
              }
              else (Resources("midSentenceAllPropertiesHadExpectedValues"), Vector(left))

            MatchResult(true, rawFailureMessage, rawFailureMessage, rawMidSentenceFailureMessage, rawMidSentenceFailureMessage, failureMessageArgs, rawMidSentenceFailureMessageArgs)
        }
      }
      
      override def toString: String = "have (" + Prettifier.default(firstPropertyMatcher) + ")"
    }
  
  /**
   * Overrides toString to return "length"
   */
  override def toString: String = "have"
}