Mockito
- Mockito: शुरुआती के लिए एक विस्तृत गाइड
Mockito एक लोकप्रिय यूनिट परीक्षण ढांचे (framework) में से एक है जो जावा में उपयोग किया जाता है। इसका उपयोग मुख्य रूप से टेस्ट डबल बनाने के लिए किया जाता है, विशेष रूप से मॉक्स, जो आपको अपने कोड के अलग-अलग हिस्सों को अलग-अलग परीक्षण करने की अनुमति देते हैं। यह लेख Mockito के मूल सिद्धांतों को समझने और इसे अपने जावा प्रोजेक्ट्स में उपयोग करने के लिए एक विस्तृत गाइड प्रदान करता है।
Mockito क्या है?
Mockito एक ओपन-सोर्स जावा लाइब्रेरी है जिसका उपयोग यूनिट परीक्षण को आसान और अधिक प्रभावी बनाने के लिए किया जाता है। यूनिट परीक्षण में, हम अपने कोड के छोटे, अलग-अलग हिस्सों को अलग से परीक्षण करते हैं ताकि यह सुनिश्चित किया जा सके कि वे सही ढंग से काम कर रहे हैं। अक्सर, किसी एक यूनिट को परीक्षण करने के लिए, हमें अन्य यूनिट्स पर निर्भरता को नियंत्रित करने की आवश्यकता होती है। यहीं पर Mockito काम आता है।
Mockito हमें मॉक्स बनाने की अनुमति देता है, जो वास्तविक निर्भरताओं के नकली संस्करण होते हैं। ये मॉक्स वास्तविक निर्भरताओं के समान व्यवहार करते हैं, लेकिन वे परीक्षण के दौरान हमारे नियंत्रण में होते हैं। इससे हम उन परिस्थितियों का अनुकरण कर सकते हैं जो वास्तविक वातावरण में दोहराना मुश्किल या असंभव हो सकती हैं।
Mockito का उपयोग क्यों करें?
Mockito का उपयोग करने के कई फायदे हैं:
- सरलता: Mockito का उपयोग करना अपेक्षाकृत आसान है, खासकर अन्य टेस्ट डबल फ्रेमवर्क की तुलना में।
- तेज़ परीक्षण: मॉक्स का उपयोग करके, हम बाहरी सिस्टम पर निर्भरता को हटा सकते हैं, जिससे हमारे परीक्षण तेज़ हो जाते हैं।
- विश्वसनीय परीक्षण: मॉक्स हमें उन परिस्थितियों का अनुकरण करने की अनुमति देते हैं जो वास्तविक वातावरण में दोहराना मुश्किल हो सकती हैं, जिससे हमारे परीक्षण अधिक विश्वसनीय हो जाते हैं।
- बेहतर डिज़ाइन: Mockito का उपयोग करने से हमें अपने कोड को अधिक मॉड्यूलर और परीक्षण योग्य बनाने के लिए प्रोत्साहित किया जाता है।
Mockito की मूलभूत अवधारणाएँ
Mockito का उपयोग करने से पहले, कुछ मूलभूत अवधारणाओं को समझना महत्वपूर्ण है:
- मॉक्स (Mocks): मॉक्स वास्तविक निर्भरताओं के नकली संस्करण हैं। उनका उपयोग उन निर्भरताओं के व्यवहार को नियंत्रित करने के लिए किया जाता है जिनका हम परीक्षण कर रहे हैं।
- स्टब्स (Stubs): स्टब्स मॉक्स के समान होते हैं, लेकिन उनका उपयोग केवल विशिष्ट इनपुट के लिए विशिष्ट आउटपुट को परिभाषित करने के लिए किया जाता है।
- स्पाइज़ (Spies): स्पाइज़ वास्तविक ऑब्जेक्ट्स हैं जिन्हें मॉनिटर किया जा सकता है। उनका उपयोग यह देखने के लिए किया जा सकता है कि किसी ऑब्जेक्ट के तरीकों को कब और कैसे कॉल किया जाता है।
- वेरिफिकेशन (Verification): वेरिफिकेशन का उपयोग यह सुनिश्चित करने के लिए किया जाता है कि किसी मॉक्स के तरीकों को अपेक्षित रूप से कॉल किया गया है।
Mockito का उपयोग कैसे करें?
Mockito का उपयोग करने के लिए, आपको पहले अपनी प्रोजेक्ट में Mockito लाइब्रेरी जोड़नी होगी। आप इसे Maven या Gradle जैसे निर्भरता प्रबंधन उपकरण का उपयोग करके कर सकते हैं।
Maven के लिए, अपनी `pom.xml` फ़ाइल में निम्नलिखित निर्भरता जोड़ें:
```xml <dependency>
<groupId>org.mockito</groupId> <artifactId>mockito-core</artifactId> <version>4.0.0</version> <scope>test</scope>
</dependency> ```
Gradle के लिए, अपनी `build.gradle` फ़ाइल में निम्नलिखित निर्भरता जोड़ें:
```gradle testImplementation 'org.mockito:mockito-core:4.0.0' // नवीनतम संस्करण की जाँच करें ```
एक बार जब आपने Mockito लाइब्रेरी जोड़ ली है, तो आप इसका उपयोग मॉक्स बनाने और अपने कोड का परीक्षण करने के लिए कर सकते हैं।
Mockito के साथ एक सरल उदाहरण
मान लीजिए कि हमारे पास एक `UserService` क्लास है जो `UserRepository` क्लास पर निर्भर करती है। हम `UserService` को `UserRepository` पर निर्भरता को अलग करके परीक्षण करना चाहते हैं।
```java // UserRepository इंटरफ़ेस public interface UserRepository {
User getUserById(int id);
}
// UserService क्लास public class UserService {
private final UserRepository userRepository;
public UserService(UserRepository userRepository) {
this.userRepository = userRepository;
}
public String getUserName(int id) {
User user = userRepository.getUserById(id);
if (user != null) {
return user.getName();
} else {
return "User not found";
}
}
} ```
अब, हम `UserService` के लिए एक यूनिट परीक्षण लिखते हैं:
```java import org.junit.jupiter.api.Test; import org.mockito.Mockito; import static org.junit.jupiter.api.Assertions.assertEquals;
public class UserServiceTest {
@Test
public void testGetUserName() {
// 1. UserRepository का एक मॉक बनाएं
UserRepository userRepository = Mockito.mock(UserRepository.class);
// 2. मॉक के व्यवहार को परिभाषित करें
User user = new User(1, "John Doe");
Mockito.when(userRepository.getUserById(1)).thenReturn(user);
// 3. UserService बनाएं और उसे मॉक UserRepository पास करें
UserService userService = new UserService(userRepository);
// 4. UserService के getUserName() विधि को कॉल करें और परिणाम की जाँच करें
String userName = userService.getUserName(1);
assertEquals("John Doe", userName);
// 5. सत्यापित करें कि UserRepository के getUserById() विधि को अपेक्षित रूप से कॉल किया गया था
Mockito.verify(userRepository).getUserById(1);
}
}
// User क्लास (उदाहरण के लिए) class User {
private int id; private String name;
public User(int id, String name) {
this.id = id;
this.name = name;
}
public String getName() {
return name;
}
} ```
इस उदाहरण में, हमने पहले `UserRepository` का एक मॉक्स बनाया। फिर, हमने `Mockito.when()` विधि का उपयोग करके मॉक के व्यवहार को परिभाषित किया। हमने कहा कि जब `userRepository.getUserById(1)` को कॉल किया जाता है, तो यह एक `User` ऑब्जेक्ट लौटाएगा जिसका नाम "John Doe" है। फिर, हमने `UserService` बनाया और उसे मॉक `UserRepository` पास किया। अंत में, हमने `UserService` के `getUserName()` विधि को कॉल किया और परिणाम की जाँच की। हमने `Mockito.verify()` विधि का उपयोग करके यह भी सत्यापित किया कि `UserRepository` के `getUserById()` विधि को अपेक्षित रूप से कॉल किया गया था।
Mockito के उन्नत उपयोग
Mockito कई उन्नत सुविधाएँ प्रदान करता है जो आपके यूनिट परीक्षण को और अधिक शक्तिशाली बना सकती हैं:
- आर्गुमेंट मैचर्स: आप `Mockito.any()` और `Mockito.eq()` जैसे आर्गुमेंट मैचर्स का उपयोग करके किसी विधि को कॉल करने के लिए विशिष्ट तर्कों का मिलान कर सकते हैं।
- कैप्चरिंग आर्गुमेंट्स: आप `Mockito.capture()` विधि का उपयोग करके किसी विधि को कॉल करने के लिए उपयोग किए गए तर्कों को कैप्चर कर सकते हैं।
- टाइमआउट्स: आप `Mockito.timeout()` विधि का उपयोग करके यह निर्दिष्ट कर सकते हैं कि किसी विधि को कॉल करने के लिए कितना समय दिया जाना चाहिए।
- अनुक्रमिक सत्यापन: आप `Mockito.inOrder()` विधि का उपयोग करके यह सत्यापित कर सकते हैं कि किसी मॉक्स के तरीकों को एक विशिष्ट क्रम में कॉल किया गया था।
अन्य उपयोगी लिंक
यहाँ कुछ अन्य उपयोगी लिंक दिए गए हैं:
- जावा
- यूनिट परीक्षण
- टेस्ट डबल
- मॉक्स
- स्टब्स
- स्पाइज़
- वेरिफिकेशन
- Maven
- Gradle
- JUnit
- टेस्ट-ड्रिवन डेवलपमेंट
- सॉफ्टवेयर परीक्षण
- एकीकरण परीक्षण
- सिस्टम परीक्षण
- स्वीकृति परीक्षण
- बाइनरी ऑप्शन ट्रेडिंग (हालांकि यह Mockito से सीधे संबंधित नहीं है, लेकिन एक संदर्भ के रूप में शामिल है)
- तकनीकी विश्लेषण (बाइनरी ऑप्शन के लिए)
- वॉल्यूम विश्लेषण (बाइनरी ऑप्शन के लिए)
- जोखिम प्रबंधन (बाइनरी ऑप्शन के लिए)
- धन प्रबंधन (बाइनरी ऑप्शन के लिए)
- बाइनरी ऑप्शन रणनीतियाँ
- बाइनरी ऑप्शन ब्रोकर
निष्कर्ष
Mockito एक शक्तिशाली और उपयोग में आसान यूनिट परीक्षण ढांचा है जो आपको अपने जावा कोड का परीक्षण करने में मदद कर सकता है। Mockito के मूल सिद्धांतों को समझकर और इसकी उन्नत सुविधाओं का उपयोग करके, आप अपने परीक्षणों की गुणवत्ता और विश्वसनीयता में सुधार कर सकते हैं।
| लाभ | विवरण |
| सरलता | सीखने और उपयोग करने में आसान। |
| गति | बाहरी निर्भरताओं को हटाकर परीक्षणों को गति देता है। |
| विश्वसनीयता | जटिल परिदृश्यों का अनुकरण करके परीक्षणों को अधिक विश्वसनीय बनाता है। |
| डिजाइन | बेहतर मॉड्यूलरिटी और परीक्षण योग्य कोड को प्रोत्साहित करता है। |
अभी ट्रेडिंग शुरू करें
IQ Option पर रजिस्टर करें (न्यूनतम जमा $10) Pocket Option में खाता खोलें (न्यूनतम जमा $5)
हमारे समुदाय में शामिल हों
हमारे Telegram चैनल @strategybin से जुड़ें और प्राप्त करें: ✓ दैनिक ट्रेडिंग सिग्नल ✓ विशेष रणनीति विश्लेषण ✓ बाजार की प्रवृत्ति पर अलर्ट ✓ शुरुआती के लिए शिक्षण सामग्री
