परीक्षणों के समानांतर निष्पादन

Question

मैंने देखा है कि एसबीटी समानांतर में मेरे specs2 परीक्षण चला रहा है। यह अच्छा लगता है, मेरे परीक्षणों में से एक को फ़ाइल से पढ़ने और लिखना शामिल है और इसलिए अप्रत्याशित रूप से विफल रहता है, उदा। निचे देखो।

वहाँ से

1. किसी भी बेहतर विकल्प धारावाहिक में चलाने के लिए सभी परीक्षणों की स्थापना कर रहे हैं,
2. अलग फाइल नाम और प्रत्येक परीक्षा के लिए आंसू-चढ़ाव का उपयोग कर?

class WriteAndReadSpec extends Specification{ 
    val file = new File("testFiles/tmp.txt") 

    "WriteAndRead" should { 
    "work once" in { 
     new FileWriter(file, false).append("Foo").close 
     Source.fromFile(file).getLines().toList(0) must_== "Foo" 
    } 
    "work twice" in { 
     new FileWriter(file, false).append("Bar").close 
     Source.fromFile(file).getLines().toList(0) must_== "Bar" 
    } 
    } 

    trait TearDown extends After { 
    def after = if(file.exists) file.delete 
    } 
} 

Answer 1

इसके अलावा ऊपर एसबीटी के बारे में लिखा है, आपको पता होना चाहिए कि specs2 डिफ़ॉल्ट रूप से समवर्ती अपनी विशिष्टताओं के सारे उदाहरण चलाता है।

आप अभी भी यह घोषणा कर सकते हैं कि, किसी दिए गए विनिर्देश के लिए, उदाहरण अनुक्रमिक रूप से निष्पादित किए जाने चाहिए। ऐसा करने के लिए, आप बस अपने विनिर्देश की शुरुआत करने के लिए sequential जोड़ें: सुइट के लिए परीक्षण के

class WriteAndReadSpec extends Specification{ 
    val file = new File("testFiles/tmp.txt") 

    sequential 

    "WriteAndRead" should { 
    ... 
    } 
} 

Answer 2

वहाँ एक तीसरा विकल्प है, जो एक विन्यास में धारावाहिक परीक्षण समूहीकरण और उन्हें अलग से चल रहे समानांतर में आराम से चल रहा है, जबकि है हो रहा है।

this wiki देखें, "समानांतर निष्पादन के लिए आवेदन" देखें।

Answer 3

wiki linkPablo Fernandezhis answer में दिया था, बहुत अच्छा है वहाँ उदाहरण है कि एक फेंक सकता है (हालांकि, विकी, मैं कर सकते हैं किया जा रहा है और यह सही किया) में एक छोटी सी त्रुटि है, हालांकि। यहां एक project/Build.scala है जो वास्तव में अपेक्षित फ़िल्टरों को संकलित और उत्पादित करता है, हालांकि मैंने वास्तव में परीक्षणों के साथ प्रयास नहीं किया था।

import sbt._ 
import Keys._ 

object B extends Build 
{ 
    lazy val root = 
    Project("root", file(".")) 
     .configs(Serial) 
     .settings(inConfig(Serial)(Defaults.testTasks) : _*) 
     .settings(
     libraryDependencies ++= specs, 
     testOptions in Test := Seq(Tests.Filter(parFilter)), 
     testOptions in Serial := Seq(Tests.Filter(serialFilter)) 
     ) 
     .settings(parallelExecution in Serial := false : _*) 

    def parFilter(name: String): Boolean = !(name startsWith "WriteAndReadSpec") 
    def serialFilter(name: String): Boolean = (name startsWith "WriteAndReadSpec") 

    lazy val Serial = config("serial") extend(Test) 

    lazy val specs = Seq(
     "org.specs2" %% "specs2" % "1.6.1", 
     "org.specs2" %% "specs2-scalaz-core" % "6.0.1" % "test" 
    ) 
} 

Answer 4

फिक्स्ड अनुक्रम रखरखाव में परीक्षण मामलों के अंतर्निर्भरता और बोझ बढ़ सकता है।

मैं फाइल सिस्टम को छुए बिना परीक्षण करने के लिए पसंद करेंगे (कोई फर्क नहीं पड़ता या तो यह व्यापार तर्क या क्रमांकन कोड है), या अगर यह अनिवार्य है (परीक्षण एकीकरण के लिए के रूप में फ़ाइल फ़ीड के साथ) तो अस्थायी फ़ाइलों को बनाने का प्रयोग करेंगे:

// Create temp file. 
File temp = File.createTempFile("pattern", ".suffix"); 
// Delete temp file when program exits. 
temp.deleteOnExit(); 

Answer 5

अन्य उत्तरों ने बताया कि उनका उपयोग कैसे करें अनुक्रमिक चलाने के लिए।

हालांकि वे वैध उत्तर हैं, मेरी राय में यह बेहतर है कि अपने परीक्षणों को समानांतर में चलाने के लिए बेहतर करें। (यदि संभव हो)

आपके उदाहरण में - प्रत्येक परीक्षण के लिए अलग-अलग फ़ाइलों का उपयोग करें। यदि आपके पास डीबी शामिल है - अलग-अलग (या यादृच्छिक) उपयोगकर्ता (या जो कुछ भी आप कर सकते हैं) का उपयोग करें आदि ...