Metodo di sovraccarico di simulazione

Question

Sto usando scalamock per deridere una classe che contiene alcuni metodi sovraccaricati ma sto ricevendo alcuni errori.

Ad esempio:

val out = mock[PrintStream] 

(out.print _).expects("cmd \r\n") 

Aumenta il seguente errore:

[error] [...]/src/test/scala/chili.scala:19: ambiguous reference to overloaded definition, 
[error] both method print in class PrintStream of type (x$1: String)Unit 
[error] and method print in class PrintStream of type (x$1: Array[Char])Unit 

Ma se provo ad usare:

(out.print(_: String)).expects("cmd \r\n") 

Inoltre ottengo un errore:

[info] [...]/src/test/scala/chili.scala:19: Unable to resolve overloaded method print 
[info]  (out.print(_: String)).expects("cmd \r\n") 
[info]    ^
[error] [...]/src/test/scala/chili.scala:19: value expects is not a member of String => Unit 
[error]  (out.print(_: String)).expects("cmd \r\n") 

C'è un modo per farlo in scala? Forse usando un'altra libreria?

Answer 1

Credo che gli errori del compilatore che si vedono abbiano a che fare con il fatto che lo scalamock non è in grado di simulare correttamente la classe PrintStream. Se un'occhiata alla scalamock scaladocs si vedrà l'affermazione:

At present, ScalaMock can only mock traits, Java interfaces, and non-final 
classes that define a default constructor 

Come la classe PrintStream non è né un'interfaccia né ha costruttore di default, la mia ipotesi è che scalamock non può deridere correttamente e gli errori che state vedendo sono un effetto collaterale di questo. Se è stato modificato il codice per utilizzare un OutputStream invece (che è un'interfaccia e, quindi, possiede restrizioni di scalamock), si potrebbe fare il vostro metodo di overload beffardo come questo:

val mockStream = mock[OutputStream]  
(mockStream.write(_:Int)) expects(1) 
(mockStream.write(_:Array[Byte])) expects(Array[Byte](1,2,3)) 

Personalmente, preferisco Mockito utilizzato entro Specs2 come fa non hanno questo tipo di restrizioni. Un esempio di una classe utilizzando PrintWriter e poi una specifica di prova per quella classe utilizzando beffardo con Mockito è la seguente:

import java.io.PrintStream 
import java.io.File 
import org.specs2.mutable.Specification 
import org.specs2.mock.Mockito 

class MockitoExample extends Specification with Mockito{ 
    val mockPrinter = mock[PrintStream] 
    val myPrinter = new MyPrintingClass{ 
    override val printer = mockPrinter 
    } 

    "A request to print and attay of strings" should{ 
    "call println on the PrintStream for each string supplied" in { 
     myPrinter print Array("foo", "bar") 
     there was one(mockPrinter).println("foo") 
     there was one(mockPrinter).println("bar") 
    } 
    } 
} 

class MyPrintingClass{ 
    val printer = new PrintStream(new File("foo.txt")) 

    def print(strings:Array[String]) = strings foreach (printer.println(_)) 
} 

Ora, questo è un esempio molto banale, utilizzando solo le verifiche post-test senza Stubbings pre-test (perché println ha un tipo di ritorno Unit), ma almeno si può vedere che Mockito non soffre delle stesse restrizioni dello scalamock. Puoi leggere ulteriori informazioni sull'utilizzo di Mockito con Specs2 here.