JUnitలో పరీక్ష వాతావరణాన్ని ఏర్పాటు చేయడం

3.1 ఉల్లేఖనాలు @BeforeEach, @AfterEach

మునుపటి ఉదాహరణలో, ప్రతి పద్ధతిలో మనం ఒక వస్తువును సృష్టించడానికి కోడ్‌ని వ్రాయవలసి ఉంటుందని గమనించండికాలిక్యులేటర్.

వాస్తవానికి, ఇది కేవలం ఒక లైన్ మాత్రమే, కానీ మేము నిజమైన సిస్టమ్‌లను పరీక్షిస్తే, మేము తరచుగా అనేక వస్తువులను సృష్టించి, కాన్ఫిగర్ చేయాల్సిన పరిస్థితిని కలిగి ఉంటాము, ఇది అనేక డజన్ల పంక్తుల కోడ్‌ను తీసుకోవచ్చు. ఉదాహరణ:

//Create an HttpClient object
   HttpClient client = HttpClient.newBuilder()
    	.version(Version.HTTP_1_1)
    	.followRedirects(Redirect.NORMAL)
        .connectTimeout(Duration.ofSeconds(20))
    	.proxy(ProxySelector.of(new InetSocketAddress("proxy.example.com", 80)))
        .authenticator(Authenticator.getDefault())
    	.build();

   //Create an HttpRequest object
  HttpRequest request = HttpRequest.newBuilder()
     .uri(new URI("https://codegym.cc"))
     .headers("Content-Type", " application/octet-stream")
     .POST( HttpRequest.BodyPublishers. ofInputStream ( () -> is; ))
     .build();

   //Call the send() method
   HttpResponse response = client.send(request, BodyHandlers.ofString());
   System.out.println(response.statusCode());
   System.out.println(response.body());

పై ఉదాహరణలో, మేము ఒక వస్తువును సృష్టించాము మరియు కాన్ఫిగర్ చేసాముHttpClientమరియు send() పద్ధతిని పరీక్షించాలనుకుంటున్నారు .

తద్వారా ప్రతిసారీ పరీక్షా పద్ధతిలో వస్తువును సృష్టించి రాయకూడదుHttpClient, దీనిని ప్రత్యేక పద్ధతికి తరలించవచ్చు మరియు ప్రత్యేక @BeforeEach ఉల్లేఖనాన్ని ఇవ్వవచ్చు . అప్పుడు జూనిట్ ప్రతి పరీక్ష పద్ధతికి ముందు ఈ పద్ధతిని పిలుస్తాడు. ఉదాహరణ:

class HttpClientTest {
     	public HttpClient client;

   	@BeforeEach
    	public void init(){
   	   client = HttpClient.newBuilder()
   	        .version(Version.HTTP_1_1)
   	        .followRedirects(Redirect.NORMAL)
   	        .connectTimeout(Duration.ofSeconds(20))
   	        .proxy(ProxySelector.of(new InetSocketAddress("proxy.example.com", 80)))
   	        .authenticator(Authenticator.getDefault())
   	        .build();
    	}

   	@Test
    	public void send200() throws Exception {
     	   //Create an HttpRequest() object
         	HttpRequest request = HttpRequest.newBuilder(new URI("https://codegym.cc")).build();

     	   //Call the send() method
     	   HttpResponse response = client.send(request, BodyHandlers.ofString());
        	assertEquals(200, response.statusCode());
        }

   	@Test
    	public void send404() throws Exception {
     	   //Create an HttpRequest() object
         	HttpRequest request = HttpRequest.newBuilder(new URI("https://codegym.cc/unknown")).build();

     	   //Call the send() method
     	   HttpResponse response = client.send(request, BodyHandlers.ofString());
        	assertEquals(404, response.statusCode());
    	}
}

మీరు తదుపరి పరీక్ష పద్ధతి తర్వాత ప్రతిసారీ కాల్ చేయబడే ప్రత్యేక పద్ధతిని కూడా సృష్టించవచ్చు మరియు ఉపయోగించిన వనరులను శుభ్రపరచడం , లాగ్‌కు ఏదైనా వ్రాయడం మొదలైనవి చేయవచ్చు. అటువంటి పద్ధతి తప్పనిసరిగా @AfterEach ఉల్లేఖనంతో గుర్తించబడాలి .

మీకు 3 పరీక్ష పద్ధతులు ఉంటే test1() , test2() మరియు test3() , అప్పుడు కాల్ ఆర్డర్ ఇలా ఉంటుంది:

• ప్రతి పద్ధతికి ముందు
• పరీక్ష1()
• ప్రతి పద్ధతి తర్వాత
• ప్రతి పద్ధతికి ముందు
• పరీక్ష2()
• ప్రతి పద్ధతి తర్వాత
• ప్రతి పద్ధతికి ముందు
• పరీక్ష3()
• ప్రతి పద్ధతి తర్వాత

3.2 ఉల్లేఖనాలు @BeforeAll, @AfterAll

అన్ని పరీక్ష పద్ధతులకు ముందు ఒకసారి పిలవబడే పద్ధతిని జోడించడానికి కూడా JUnit మిమ్మల్ని అనుమతిస్తుంది . అటువంటి పద్ధతిని @BeforeAll తో ఉల్లేఖించాలి . ఇది జత చేసిన @AfterAll ఉల్లేఖనాన్ని కూడా కలిగి ఉంది . దానితో గుర్తించబడిన పద్ధతి అన్ని పరీక్ష పద్ధతుల తర్వాత JUnit ద్వారా పిలువబడుతుంది.

ఇది ఎలా పని చేస్తుందో బాగా అర్థం చేసుకోవడానికి మిమ్మల్ని అనుమతించే ఒక ప్రత్యేక ఉదాహరణను వ్రాద్దాం. మా కాలిక్యులేటర్ యొక్క పరీక్షను ప్రాతిపదికగా తీసుకుందాం:

class CalculatorTest {
    private Calculator calc = new Calculator();

    @BeforeAll
    public static void init(){
        System.out.println("BeforeAll init() method called");
    }

    @BeforeEach
    public void initEach(){
        System.out.println("BeforeEach initEach() method called");
    }

    @Test
    public void add(){
        System.out.println("Testing Addition");
    }

    @Test
    public void sub() {
        System.out.println("Testing Subtraction");
    }

    @Test
    public void mul(){
        System.out.println("Testing Multiplication");
    }

    @Test
    public void div() {
        System.out.println("Testing Division");
    }
}

ఈ పరీక్ష కన్సోల్‌కు కింది వచనాన్ని ప్రింట్ చేస్తుంది:

BeforeAll init() method called
BeforeEach initEach() method called
Testing Addition
 
BeforeEach initEach() method called
Testing Subtraction
 
BeforeEach initEach() method called
Testing Multiplication
 
BeforeEach initEach() method called
Testing Division