wykonanie kodu przed i po specyfikacji

Question

mam prostą specyfikację z kilku spraw, w tym:

class MySpec extends Specification { 

    "Something" should { 

    "case 1" in { 
     ... 
    } 

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

Teraz trzeba uruchomić aplikację, należy uruchomić wszystkie przypadki i zamykania aplikacji. Uruchamianie/zatrzymywanie aplikacji jest czasochłonne i nie chcę, aby tak się działo w każdym przypadku.

Jak uruchomić kod przed uruchomieniem spraw i po zakończeniu wszystkich spraw?

Answer 1

Wymyśliłem następujące rozwiązanie oparte na odpowiedzi 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() 
} 

Następnie wymieszać BeforeAllAfterAll w Specification i wdrożenie beforeAll i afterAll metody:

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 { 
     ... 
    } 
    } 
} 

Wreszcie inicjalizacji wyciąg podzielić go między specyfikacją:

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

Okay, jak wspomniano w moim komentarzu, faktycznie miałem ten sam problem. Musiałem przetestować niefiltrowane punkty końcowe, a najlepszym sposobem dla każdej specyfikacji było uruchomienie niefiltrowanego serwera z jednym punktem końcowym, uruchomienie specyfikacji, a następnie zamknięcie serwera. Aby to osiągnąć, najpierw zdefiniowano specyfikacji bazowy podobny do tego:

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 
} 

Zasadniczo, ta klasa podstawy składającą kompletny opis jako etap ustawiania i etap teardown z rzeczywistym opisie (zdefiniowaną w konkretnej klasy specyfikacji) wciśnięty w środku. Więc badanie przy użyciu tej klasy bazowej będzie wyglądać następująco:

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 
     }  
    } 
    } 
} 

Po uruchomieniu tego widać:

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

To nie jest idealne, ale to działa. Czy istnieje inny (i możliwy do czyszczenia/lepszy) sposób, aby to zrobić? Prawdopodobnie, ale jest to jedno rozwiązanie, które można rozważyć przy użyciu.

Answer 3

Ok jest to stara sprawa, ale może pomóc komuś.

Używam Play Framework. W moich testów użyłem org.scalatest.BeforeAndAfterAll

Przykład:

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") 
    } 
}