ScalaTest के साथ JUnit @Rule का उपयोग करना (उदा। अस्थायी फ़ोल्डर)

Question

मैं TemporaryFolder या अन्य TestRule जैसे जुनीट नियमों का उपयोग करने में सक्षम होना चाहता हूं, हमने पहले ही घर में विकसित किया है। इसे पूरा करने के लिए सबसे अच्छी विधि क्या है? मुझे जुनीट सूइट के बारे में पता है लेकिन यह @Rule एनोटेशन लेने की प्रतीत नहीं होता है। मैं वैसे भी एक अलग ScalaTest सूट का उपयोग करना चाहता हूँ।

तो मेरी प्रश्न हैं:

• JUnit नियम एक ScalaTest सूट द्वारा समर्थित हैं?
• यदि नहीं, तो वहाँ एक पुस्तकालय है जो जूनिट TestRule संभव का उपयोग करेगा?
• यदि नहीं, तो स्कैला परीक्षणों में जुनीट TestRule एस का उपयोग कैसे करें?
• या TemporaryFolder, या, उदाहरण के लिए, स्टीफन Birkner के System Rules प्रदान करने के लिए एक और अधिक उपयुक्त स्कैला-विशिष्ट दृष्टिकोण है?

---

यहाँ है कि मैं क्या JUnitSuite साथ करने की कोशिश की है:

class MyTest extends JUnitSuite { 
    //@Rule 
    //val temporaryFolder = new TemporaryFolder() // throws java.lang.Exception: The @Rule 'temporaryFolder' must be public. 

    @Rule 
    def temporaryFolder = new TemporaryFolder() 

    @Test 
    def test: Unit = { 
    assert(temporaryFolder.newFile() !== null) // java.lang.IllegalStateException: the temporary folder has not yet been created 
    } 
} 

Answer 1

आप TemporaryFolder के सदस्य क्षेत्र बनाकर समस्या को हल कर सकते हैं और @Rule फ़ंक्शन द्वारा इस फ़ील्ड मान को वापस कर सकते हैं।

class MyTest extends JUnitSuite { 

    val _temporaryFolder = new TemporaryFolder 

    @Rule 
    def temporaryFolder = _temporaryFolder 

    @Test 
    def test: Unit = { 
    assert(temporaryFolder.newFile() !== null) 
    } 
} 

Answer 2

यहाँ है कि मैं क्या ScalaTest के documentation on fixtures के आधार पर आया है। फिर भी, मैं जानना चाहता हूं कि कोई बेहतर समाधान है या नहीं।

1. ऋण स्थिरता विधि

   class LoanFixtureTest extends FunSuite { 
       def withRule[T <: TestRule](rule: T)(testCode: T => Any): Unit = { 
       rule(
        new Statement() { 
        override def evaluate(): Unit = testCode(rule) 
        }, 
        Description.createSuiteDescription("JUnit rule wrapper") 
       ).evaluate() 
       } 
   
       test("my test") { 
       withRule(new TemporaryFolder()) { temporaryFolder => 
        assert(temporaryFolder.newFile() !== null) 
       } 
       } 
   } 
   

   • लाभ: केवल परीक्षण जहां यह
   • विपक्ष की जरूरत है के लिए नियम लागू करने की अनुमति देता है: बहुत ही सुंदर नहीं उपयोग; अनाड़ी जब कई TestRules withFixture(test: NoArgTest) ओवरराइड

     trait TemporaryFolderFixture1 extends SuiteMixin { 
         this: Suite => 
         val temporaryFolder = new TemporaryFolder 
     
         abstract override def withFixture(test: NoArgTest) = { 
         var outcome: Outcome = null 
         val statementBody =() => outcome = super.withFixture(test) 
         temporaryFolder(
          new Statement() { 
          override def evaluate(): Unit = statementBody() 
          }, 
          Description.createSuiteDescription("JUnit rule wrapper") 
         ).evaluate() 
         outcome 
         } 
     } 
     
     class StackableTraitFixtureTest extends FunSuite with TemporaryFolderFixture1 { 
         test("my test") { 
         assert(temporaryFolder.newFile() !== null) 
         } 
     } 
     

     • पेशेवरों के साथ

   • stackable mixins का उपयोग करना आवश्यक हैं: बहुत ही सरल उपयोग, आसानी से

   • विपक्ष अनेक नियमों मिश्रण की अनुमति देता है: आवश्यकता के लिए एक mixin होने हर नियम; नियमों को उन परीक्षणों के लिए भी बुलाया जाना चाहिए जिनकी आवश्यकता नहीं है; नियम का उपयोग नहीं किया जा सकता है उदा। BeforeAfterEach#beforeEach() में

2. withFixture(test: OneArgTest)

   trait TemporaryFolderFixture2 { 
       thisFixture: org.scalatest.fixture.FunSuite => 
       type FixtureParam = TemporaryFolder 
   
       override protected def withFixture(test: OneArgTest): Outcome = { 
       val temporaryFolder = new TemporaryFolder() 
       var outcome: Outcome = null 
       temporaryFolder(
        new Statement() { 
        override def evaluate(): Unit = { 
         outcome = withFixture(test.toNoArgTest(temporaryFolder)) 
        } 
        }, 
        Description.createSuiteDescription("JUnit rule wrapper") 
       ).evaluate() 
       outcome 
       } 
   } 
   
   class OneArgWithFixtureTest extends org.scalatest.fixture.FunSuite with TemporaryFolderFixture2 { 
       test("my test") { temporaryFolder => 
       assert(temporaryFolder.newFile() !== null) 
       } 
   } 
   

   • विपक्ष ओवरराइड: केवल एक TestRule की अनुमति देता है, सामान्य में बना बस TestRule के बजाय किसी भी नियम के साथ काम करने के लिए एक अतिरिक्त प्रयास

की आवश्यकता होगी

आपको कौन सा सबसे अच्छा पसंद है?

Answer 3

यह मेरे लिए काम करता था। answer के आधार पर। इसलिए एनोटेशन पर (सिंथेटिक) गेटर विधि

import org.junit._ 
import scala.annotation.meta.getter 

class MyTest extends JUnitSuite { 

    @(Rule @getter) 
    val tempFolder = new TemporaryFolder 

}