스칼라 테스트

Question

나는 예를 들어, 농축을 입력 부착 될 것

나는이

object Algorithm{ 
    def apply(rand: Random) = { 
    import MyImplicits._ 
    rand.nextInt.complexCalculation + 1 
    } 
} 

같은 코드에 사용하지만 지금은 분리 및 단위 테스트 알고리즘 방법

object MyImplicits{ 
    implicit class RichInt(i: Int){ 
    def complexCalculation: Int = i * 200 
    } 
} 

? 특히,이 같은 complexCalculation의 실현하는 것이, 무언가를 조롱하고 싶습니다 :

는

class MyAlgorithmTest extends FreeSpec with MockitoSugar{ 
    import org.mockito.Mockito.when 

    "MyApgorithm" { 
    "Delegates complex calculation" in { 
     val mockRandom = mock[Random] 
     when(mockRandom.nextInt()).thenReturn(1) 

     // This wouldn't work, but is the kind of thing I'm looking for 
     //when(1.complexCalculation).thenReturn(2) 
     val expected = 1 * 2 + 1 

     val result = MyAlgorithm(mockRandom) 
     assert(result === expected) 
    } 
    } 
} 

Answer 1

Implicits를 사용하면 구성이 가능하며, 구성 할 때 테스트를 위해 구현을 대체 할 수 있으므로 일반적으로 mock이 필요하지 않습니다. 즉, 나는이 경우에 함축 된 팬이 아니며, 그들이 가져다주는 가치를 보지 못한다. (내 다른 의견에 암시로) 나는 오래된 학교 조성 그것을 해결 것 :

당신이 구성을 할 implicits를 사용하여 주장하는 경우

trait Calculation { 
    def calculation(i: Int): Int 
} 

trait ComplexCalculation extends Calculation { 
    def calculation(i: Int): Int = i * 200 
} 

trait MyAlgorithm { 
    self: Calculation => 

    def apply(rand: Random) = { 
    calculation(rand.nextInt) + 1 
    } 
} 

// somewehre in test package 

trait MockCalculation extends Calculation { 
    def calculation(i: Int): Int = i * 200 
} 

//test instance 
object MyAlgorithm extends MyAlgorithm with MockCalculation 

,이 작업을 수행 할 수 있습니다

trait Computation { 
    def compute(i: Int): Int 
} 

object prod { 
    implicit val comp = new Computation { 
    def compute(i: Int): Int = i * 200 
    } 
} 

object test { 
    implicit val comp = new Computation { 
    def compute(i: Int): Int = i + 2 
    } 
} 

object Algorithm { 
    def apply(rand: Random)(implicit comp: Computation) = { 
    comp.compute(i) + 1 
    } 
} 

// application site 
import prod._ 

Algorithm(scala.util.Random) // will run * 200 computation 

//test 

import test._ 

Algorithm(scala.util.Random) // will run + 2 computation 

이 원 ' 하지만 당신에게 계산을위한 도트 구문을주지 마라. 이 방법은 행동을 정의하는 매우 미묘한 방법이기 때문에 가져 오는 가져 오기와 실수를하기 쉽습니다.

Answer 2

다음은 scalatest API를 사용합니다. 모의 테스트가 잘 실행되고 있으며 암시 적 클래스 변환이 제대로 수행되고 있습니다.

// Implicit.scala in src/main/scala 

package implicittesting 
import scala.util.Random 

object MyImplicits{ 
    implicit class RichInt(i: Int){ 
    def complexCalculation: Int = 200*i // make this complex :) 
    } 
} 

object Algorithm{ 
    var current = 1 
    def apply(rand: Random) = { 
    import MyImplicits._ 
    current = rand.nextInt 
    current.complexCalculation + 100 
    } 
} 


// ImplicitSuite.scala in src/main/test 

package implicittesting 

import org.scalatest.FunSuite 


import org.junit.runner.RunWith 
import org.scalatest.junit.JUnitRunner 

@RunWith(classOf[JUnitRunner]) 
class DeleteSuite extends FunSuite { 
    import MyImplicits._ 
    test("algorithm implicit class conversion test") { 
    assert(Algorithm(scala.util.Random) == Algorithm.current.complexCalculation + 200) 
    println(Algorithm.current) 
    } 
} 

Answer 3

이것은 내가 생각해 낸 최고입니다. 나는 그것을 사기꾼이라고 인정하는 것을 기꺼이한다.

import org.scalatest.FreeSpec 
import org.scalatest.mockito.MockitoSugar 
import scala.util.Random 

trait MyImplicits { 
    implicit class RichInt(i: Int){ 
    def complexCalculation: Int = complexCalculationImpl(i) 
    } 

    def complexCalculationImpl(i: Int) = i * 200 
} 

trait MyAlgorithm extends MyImplicits { 
    def apply(rand: Random) = { 
    rand.nextInt.complexCalculation + 1 
    } 
} 

//Implementation for use 
object MyAlgorithm extends MyAlgorithm 

class MyAlgorithmTest extends FreeSpec with MockitoSugar{ 
    import org.mockito.Mockito.when 

    "MyApgorithm should" - { 
    "Delegate the complex calculation" in { 
     val mockRandom = mock[Random] 
     when(mockRandom.nextInt()).thenReturn(1) 

     val instance = new MyAlgorithm { 
     override def complexCalculationImpl(i: Int) = i * 2 
     } 

     val expected = 3 // Note we don't expect 201 

     assert(instance(mockRandom) === expected) 
    } 
    } 
} 

Answer 4

RichInt.scala

trait RichInt { 
    def complexCalculation: Int 
} 

class RichIntImpl(i: Int) extends RichInt { 
    def complexCalculation = i * 200 
} 

Algorithm.scala

import scala.util.Random 

class Algorithm(enrich: Int => RichInt) { 
    implicit val _enrich = enrich 
    def apply(rand: Random) = { 
    rand.nextInt.complexCalculation + 1 
    } 
} 

object Algorithm extends Algorithm(new RichIntImpl(_)) 

AlgorithmTest.scala

import org.scalatest.FreeSpec 
import scala.util.Random 
import org.mockito.Mockito._ 

class AlgorithmTest extends FreeSpec with MockSugar { 

    "MyApgorithm should" - { 
    "Delegate the complex calculation" in { 
     val mockRandom = mock[Random] 
     when(mockRandom.nextInt()) thenReturn 1 

     val algorithm = new Algorithm(
     enrich = mocking[Int => RichInt] { enrich => 
      when(enrich(1)).thenReturnMocking { richInt => 
      when(richInt.complexCalculation).thenReturn(2) 
      } 
     } 
    ) 

     val expected = 3 

     assert(algorithm(mockRandom) === expected) 
    } 
    } 
} 

MockSuger.scala

,

import org.scalatest.mockito.MockitoSugar 
import org.mockito.stubbing.OngoingStubbing 

// More sugars to make our tests look better. 
trait MockSugar extends MockitoSugar { 

    def mocking[T <: AnyRef : Manifest](behavior: T => Unit): T = { 
    val m = mock[T] 
    behavior(m) 
    m 
    } 

    implicit class RichOngoingStubbing[T <: AnyRef : Manifest](stub: OngoingStubbing[T]) { 
    def thenReturnMocking(behavior: T => Unit) = { 
     val m = mock[T] 
     val s = stub.thenReturn(m) 
     behavior(m) 
     s 
    } 
    } 
}