eseguire codice prima e dopo la specifica

Question

ho semplice specifica con diversi casi in esso:

class MySpec extends Specification { 

    "Something" should { 

    "case 1" in { 
     ... 
    } 

    "case 2" in { 
     ... 
    } 
    } 
} 

Ora ho bisogno di avviare l'applicazione, eseguire tutti i casi, e l'arresto l'applicazione. L'avvio/arresto dell'applicazione richiede molto tempo e non voglio che accada in ogni caso.

Come si esegue il codice prima dell'avvio dei casi e al termine di tutti i casi?

Answer 1

Ho trovato la seguente soluzione basata sulla risposta di cmbaxter.

import org.specs2.specification.Step 

trait BeforeAllAfterAll extends Specification { 
    // see http://bit.ly/11I9kFM (specs2 User Guide) 
    override def map(fragments: =>Fragments) = 
    Step(beforeAll)^fragments^Step(afterAll) 

    protected def beforeAll() 
    protected def afterAll() 
} 

Poi mescolare BeforeAllAfterAll in Specification e implementare beforeAll e afterAll metodi:

class MySpec extends Specification with BeforeAllAfterAll { 

    def beforeAll() { 
    println("Doing setup work...") 
    } 

    def afterAll() { 
    println("Doing shutdown work...") 
    } 

    "Something" should { 

    "case 1" in { 
     ... 
    } 

    "case 2" in { 
     ... 
    } 
    } 
} 

Infine, l'inizializzazione estratto di condividerlo tra le specifiche:

trait InApplication extends BeforeAllAfterAll { 
    def beforeAll() { 
    println("Doing setup work...") 
    } 

    def afterAll() { 
    println("Doing shutdown work...") 
    } 
} 

class MySpec extends Specification with InApplication { 

    "Something" should { 

    "case 1" in { 
     ... 
    } 

    "case 2" in { 
     ... 
    } 
    } 
} 

Answer 2

Ok, come accennato nel mio commento, ho effettivamente avuto lo stesso problema. Avevo bisogno di testare gli endpoint Unfiltered e il modo migliore per ogni specifica era avviare un server Unfiltered con un singolo endpoint, eseguire le specifiche e quindi arrestare il server. Per ottenere questo, ho definito una specifica base simile a questo:

import org.specs2.mutable.Specification 

abstract class SpecificationBase extends Specification{ 
    //Do setup work here 
    step{ 
    println("Doing setup work...") 
    success 
    } 

    //Include the real spec from the derived class 
    include(spec) 

    //Do shutdown work here 
    step{ 
    println("Doing shutdown work...") 
    success 
    } 

    /** 
    * To be implemented in the derived class. Returns the real specification 
    * @return Specification 
    */ 
    def spec:Specification 
} 

Fondamentalmente, questa classe di base assembla la specifica completa come una fase di installazione ed una fase di smontaggio con la specifica reale (definito nella classe spec cemento) inserito nel mezzo. Quindi un test utilizzando questa classe di base sarebbe simile a questa:

class MySpec extends SpecificationBase{ def spec = 
    new Specification{ 
    "A request to do something" should{ 
     "be successful in case 1" in { 
     println("Testing case 1") 
     success 
     } 
     "be successful in case 2" in { 
     println("Testing case 2") 
     success 
     }  
    } 
    } 
} 

Quando si esegue questo, si vedrà:

Doing setup work... 
Testing case 1 
Testing case 2 
Doing shutdown work... 

non è perfetto, ma funziona. C'è un altro (e possibile metodo più pulito/migliore) per farlo? Probabilmente, ma questa è una soluzione che potresti esaminare usando.

Answer 3

Ok questo è una vecchia questione, ma potrebbe aiutare qualcuno.

Sto utilizzando Play Framework. Nei miei test ho usato org.scalatest.BeforeAndAfterAll

Esempio:

import org.scalatest.BeforeAndAfterAll 

class MySpec extends PlaySpec with BeforeAndAfterAll { 

    "Some test" must { 
    "print a text" in { 

     println("Some test") 
     2 mustBe 2 
    } 
    } 

    override def beforeAll(): Unit = { 
    println("Before") 
    } 

    override def afterAll(): Unit = { 
    println("After") 
    } 
}