రస్ట్ చైల్డ్ మాడ్యూల్‌లో mod.rsని యాక్సెస్ చేయడానికి టెస్ట్ ఫైల్‌ను ఎలా ఉపయోగించాలి

రస్ట్ ప్రాజెక్ట్‌లలో మాడ్యూల్ యాక్సెస్‌ని అన్వేషించడం

రస్ట్‌తో పని చేస్తున్నప్పుడు, క్లీన్ మరియు మాడ్యులర్ కోడ్‌ను నిర్వహించడానికి మాడ్యూల్‌లను ఎలా నిర్మించాలో మరియు యాక్సెస్ చేయాలో అర్థం చేసుకోవడం చాలా అవసరం. మీరు రస్ట్‌తో ప్రారంభించినట్లయితే లేదా ఇప్పటికే ఉన్న ప్రాజెక్ట్‌లో పని చేస్తుంటే, మీ ప్రాజెక్ట్ డైరెక్టరీలోని వివిధ భాగాలలో ఉన్న మాడ్యూల్‌లను యాక్సెస్ చేయడంలో మీరు సవాలును ఎదుర్కోవచ్చు. ఇది గమ్మత్తైనది, ప్రత్యేకించి ప్రధాన సోర్స్ కోడ్ వెలుపల ఉన్న టెస్ట్ ఫైల్ నుండి చైల్డ్ మాడ్యూల్‌ను సూచించడానికి ప్రయత్నిస్తున్నప్పుడు. 🔍

రస్ట్ ప్రాజెక్ట్ సందర్భంలో, ప్రాజెక్ట్ యొక్క వివిధ భాగాల నుండి `mod.rs` ఫైల్‌ను యాక్సెస్ చేయగల సామర్థ్యం పరీక్ష మరియు మాడ్యులారిటీకి ముఖ్యమైనది. `mod.rs` ఫైల్ మాడ్యూల్‌కు ఎంట్రీ పాయింట్‌గా పనిచేస్తుంది మరియు ఇది తరచుగా సబ్‌ఫోల్డర్‌లోని కంటెంట్‌లను నిర్వహించడానికి ఉపయోగించబడుతుంది. ప్రామాణిక `src/` డైరెక్టరీ వెలుపల ఉన్న `పరీక్షలు/` ఫోల్డర్ నుండి ఈ ఫైల్‌ని యాక్సెస్ చేయడానికి ప్రయత్నిస్తున్నప్పుడు ఒక సాధారణ సమస్య తలెత్తుతుంది. 🛠️

మీరు `src/` డైరెక్టరీలో `కంట్రోలర్‌లు/` ఫోల్డర్‌ని కలిగి ఉన్న ప్రాజెక్ట్‌తో పని చేస్తున్నారని అనుకుందాం మరియు మీరు దాని కార్యాచరణలో కొంత భాగాన్ని పరీక్షించాలనుకుంటున్నారు. `tests/test.rs` ఫైల్ నుండి `mod.rs` ఫైల్‌ని సరిగ్గా ఎలా దిగుమతి చేయాలో మరియు యాక్సెస్ చేయాలో తెలుసుకోవడం మీ పరీక్ష ప్రక్రియను సులభతరం చేస్తుంది. అయినప్పటికీ, రస్ట్ యొక్క మాడ్యూల్ సిస్టమ్‌కు సాపేక్ష మార్గాలు మరియు మాడ్యూల్ విజిబిలిటీపై మంచి అవగాహన అవసరం.

తదుపరి విభాగంలో, `test.rs` ఫైల్ నుండి `కంట్రోలర్‌లు` ఫోల్డర్‌లోని `mod.rs`ని సరిగ్గా సూచించడం ద్వారా ఈ సమస్యను పరిష్కరించడానికి మేము దశల ద్వారా వెళ్తాము. చివరికి, మీరు ఈ సవాలును నిర్వహించడానికి మరియు మీ రస్ట్ ప్రాజెక్ట్‌ల కోసం సమర్థవంతమైన పరీక్షలను అమలు చేయడానికి సన్నద్ధమవుతారు. ప్రక్రియను వివరించడానికి కొన్ని ఆచరణాత్మక ఉదాహరణలలోకి ప్రవేశిద్దాం!

ఆదేశం	ఉపయోగం యొక్క ఉదాహరణ
mod	రస్ట్ ప్రాజెక్ట్‌లో ఒక మాడ్యూల్‌ను ప్రకటిస్తుంది. ఇది ఇతర ఫైల్‌లను (ఉదా., మోడ్ కంట్రోలర్‌లు;) లేదా సబ్‌మాడ్యూల్స్ వంటి కోడ్‌లోని నిర్దిష్ట భాగాలను చేర్చడానికి మరియు సూచించడానికి ఉపయోగించవచ్చు.
#[cfg(test)]	పరీక్షలను అమలు చేస్తున్నప్పుడు మాత్రమే కోడ్‌లోని ఏ భాగాన్ని కంపైల్ చేయాలో పేర్కొనే లక్షణాలు. ఇది పరీక్ష-నిర్దిష్ట లాజిక్‌ను ప్రధాన కోడ్‌బేస్ నుండి వేరు చేయడంలో సహాయపడుతుంది, పరీక్ష కోడ్ ఉత్పత్తి కోడ్‌ను ప్రభావితం చేయదని నిర్ధారిస్తుంది.
use	నిర్దిష్ట మాడ్యూల్‌లు, ఫంక్షన్‌లు లేదా రకాలను పరిధిలోకి తీసుకురావడానికి ఉపయోగిస్తారు. ఉదాహరణకు, కంట్రోలర్‌లను ఉపయోగించండి :: sms; పరీక్ష ఫైల్‌లోకి `కంట్రోలర్‌లు` డైరెక్టరీ నుండి `sms` మాడ్యూల్‌ని తీసుకువస్తుంది.
pub	ఈ కీవర్డ్ మాడ్యూల్, ఫంక్షన్ లేదా వేరియబుల్‌ను దాని ప్రస్తుత పరిధి వెలుపల నుండి యాక్సెస్ చేయగలదు. `mod.rs`లోని ఫంక్షన్‌ల వంటి మీ కోడ్‌లోని భాగాలు పరీక్షలతో సహా ఇతర మాడ్యూల్‌లకు కనిపించేలా చూసుకోవడానికి ఇది ఉపయోగించబడుతుంది.
#[test]	ఫంక్షన్‌ను యూనిట్ టెస్ట్‌గా గుర్తు చేస్తుంది. రస్ట్ యొక్క అంతర్నిర్మిత పరీక్ష ఫ్రేమ్‌వర్క్ ఈ ఉల్లేఖనాన్ని పరీక్షలుగా అమలు చేయడానికి ఫంక్షన్‌లను గుర్తించడానికి ఉపయోగిస్తుంది, ఉదా., #[test] fn test_sms().
assert_eq!	రెండు వ్యక్తీకరణలు ఒకే విలువకు మూల్యాంకనం చేస్తున్నాయో లేదో తనిఖీ చేయడానికి ఉపయోగించబడుతుంది. విలువలు సమానంగా లేకుంటే, పరీక్ష విఫలమవుతుంది. ఉదాహరణకు, assert_eq!(ఫలితం, సరే("సందేశం విజయవంతంగా పంపబడింది!")); ఫలితం ఆశించిన అవుట్‌పుట్‌తో సరిపోలుతుందో లేదో తనిఖీ చేస్తుంది.
Err	రస్ట్‌లో ఫలితం రకం యొక్క రూపాంతరాన్ని సూచిస్తుంది, ఇది లోపం లేదా వైఫల్యాన్ని సూచిస్తుంది. Err("చెల్లని ఇన్‌పుట్")లో చూసినట్లుగా, వైఫల్య పరిస్థితిని అనుకరించడానికి ఇది పరీక్ష సందర్భంలో ఉపయోగించబడుతుంది.
Ok	ఫలితాల రకం యొక్క విజయవంతమైన రూపాంతరాన్ని సూచిస్తుంది. ఇది సరే ("సందేశం విజయవంతంగా పంపబడింది!") వంటి విజయవంతమైన ఫలితాన్ని అనుకరించడానికి పరీక్షలలో ఉపయోగించబడుతుంది.
mod.rs	డైరెక్టరీ కోసం మాడ్యూల్‌ను ప్రకటించడానికి రస్ట్ ఉపయోగించే ఫైల్ పేరు. ఇది ఒకే ఫోల్డర్‌లో సబ్‌మాడ్యూల్‌లను నిర్వహించడంలో సహాయపడుతుంది, మీరు పేరెంట్ ఫోల్డర్‌ను సూచించినప్పుడు వాటిని యాక్సెస్ చేయగలదు, ఉదా., మోడ్ కంట్రోలర్‌లు; `కంట్రోలర్‌లు/mod.rs`ని యాక్సెస్ చేస్తుంది.

స్క్రిప్ట్‌ను అర్థం చేసుకోవడం: రస్ట్‌లో చైల్డ్ మాడ్యూల్‌లను యాక్సెస్ చేయడం

మునుపటి ఉదాహరణలో, మేము ఎలా యాక్సెస్ చేయాలో అన్వేషించాము లోపల ఫైల్ లో ఉన్న టెస్ట్ ఫైల్ నుండి ఫోల్డర్ డైరెక్టరీ. స్క్రిప్ట్‌లు ఎలా పని చేస్తాయి మరియు ప్రతి భాగం ఎందుకు ముఖ్యమైనది అనే దాని గురించి లోతుగా డైవ్ చేద్దాం. మొదటి దశ మీ రస్ట్ ప్రాజెక్ట్‌లోని మాడ్యూల్‌లను డిక్లేర్ చేయడం, ముఖ్యంగా దీన్ని ఉపయోగించడం mod సూచించడానికి కీవర్డ్ కంట్రోలర్లు మీ ప్రధాన కోడ్‌బేస్ నుండి మాడ్యూల్. ఇది యొక్క కంటెంట్లను చేస్తుంది కంట్రోలర్లు ఫోల్డర్, వంటి , పరీక్షలతో సహా మీ మిగిలిన కోడ్‌ని యాక్సెస్ చేయవచ్చు. ఈ డిక్లరేషన్ లేకుండా, మీ టెస్ట్ ఫైల్‌లు మాడ్యూల్‌ను కనుగొనలేవు లేదా ఉపయోగించలేవు. ఇది ఒక స్థానానికి స్పష్టమైన చిరునామాను అందించడం లాంటిది-అది లేకుండా, సిస్టమ్ ఎక్కడికి వెళ్లాలో తెలియదు. 🛠️

ఈ స్క్రిప్ట్‌ల యొక్క మరొక ముఖ్య అంశం ఏమిటంటే దీని ఉపయోగం గుణం. ఈ గుణం రస్ట్‌కి టెస్టింగ్ సమయంలో మాత్రమే కోడ్‌లోని నిర్దిష్ట భాగాలను కంపైల్ చేసి చేర్చమని చెబుతుంది. మా విషయంలో, ఇది పరీక్ష ఫంక్షన్‌లను వేరుచేయడానికి ఉపయోగించబడుతుంది, కాబట్టి అవి అప్లికేషన్ యొక్క ప్రధాన తర్కాన్ని ప్రభావితం చేయవు. ఈ విధానం క్లీన్ కోడ్‌ని నిర్వహించడంలో సహాయపడుతుంది మరియు పరీక్ష లాజిక్ ఉత్పత్తి కోడ్‌తో జోక్యం చేసుకోకుండా చూసుకోవడంలో సహాయపడుతుంది. మీరు సిస్టమ్ పనితీరు లేదా కార్యాచరణను తనిఖీ చేయడానికి సిద్ధంగా ఉన్నప్పుడు మాత్రమే సక్రియం చేసే పరీక్షా వాతావరణాన్ని కలిగి ఉన్నట్లు మీరు భావించవచ్చు. ఇది సిస్టమ్ స్థిరంగా ఉండేలా మరియు పరీక్ష కార్యకలాపాల ద్వారా ప్రభావితం కాకుండా ఉండేలా చేస్తుంది.

ది నిర్దిష్ట మాడ్యూల్స్ లేదా ఫంక్షన్‌లను స్కోప్‌లోకి తీసుకురావడంలో కీవర్డ్ కీలక పాత్ర పోషిస్తుంది. స్క్రిప్ట్‌లో, యాక్సెస్ చేయడానికి మమ్మల్ని అనుమతిస్తుంది లోపల మాడ్యూల్ కంట్రోలర్లు పరీక్ష ఫైల్ నుండి ఫోల్డర్. ఇది అన్ని పబ్లిక్ ఫంక్షన్లను లోపల చేస్తుంది అందుబాటులో, వంటి ఫంక్షన్, ఇది ఆశించిన విధంగా పనిచేస్తుందో లేదో ధృవీకరించడానికి మేము పరీక్షిస్తాము. కోడ్ పునర్వినియోగం మరియు మాడ్యులారిటీ కోసం రస్ట్‌లో ఈ విధానం ఒక సాధారణ నమూనా. మీరు లైబ్రరీలో ఉన్నారని ఊహించుకోండి మరియు మీ పనిని పూర్తి చేయడానికి షెల్ఫ్ నుండి మీకు అవసరమైన నిర్దిష్ట పుస్తకాన్ని పొందడం లాంటిది-ఇది కోడ్‌లోని సంబంధిత భాగాలను మాత్రమే మీకు అందుబాటులో ఉంచడం ద్వారా సమయం మరియు కృషిని ఆదా చేస్తుంది. 📚

చివరగా, ది ఉల్లేఖన మరియు మా యూనిట్ పరీక్షలను అమలు చేయడానికి మరియు ధృవీకరించడానికి మాక్రో అవసరం. ఒక ఫంక్షన్‌ను టెస్ట్ కేస్‌గా గుర్తు చేస్తుంది, ఇది రస్ట్ టెస్ట్ ఫ్రేమ్‌వర్క్ ద్వారా స్వయంచాలకంగా గుర్తించబడుతుంది. స్క్రిప్ట్‌లో, మేము ఉపయోగించాము assert_eq! యొక్క వాస్తవ ఫలితంతో ఆశించిన ఫలితాన్ని పోల్చడానికి ఫంక్షన్. విలువలు సరిపోలకపోతే, పరీక్ష విఫలమవుతుంది, మా కోడ్ యొక్క కార్యాచరణపై మాకు తక్షణ అభిప్రాయాన్ని అందిస్తుంది. ఇది మా మాడ్యూల్స్ ఆశించిన విధంగా పని చేసేలా చేయడంలో మాకు సహాయపడుతుంది మరియు సమస్యలను త్వరగా గుర్తించి, పరిష్కరించేందుకు మమ్మల్ని అనుమతిస్తుంది. ఇది డెవలప్‌మెంట్ సమయంలో భద్రతా వలయాన్ని కలిగి ఉండటం లాంటిది-ఏదైనా తప్పు జరిగితే, పరీక్ష దాన్ని క్యాచ్ చేస్తుంది మరియు సరిగ్గా ఎక్కడ చూడాలో మాకు తెలియజేస్తుంది.

mod controllers; // Declare the module from the controllers folder
use controllers::sms; // Use a specific module inside controllers
#[cfg(test)] // Mark the module for testing only
mod tests; // Declare the test module
#[cfg(test)] // Only compile the test code in test configuration
use crate::controllers::sms::send_sms; // Example of using the sms.rs file from controllers
#[test] // Declare a test function
fn test_sms_function() {
    assert_eq!(send_sms("12345", "Test message"), Ok("Message sent successfully!")); // Test the function
}

mod controllers { // Declare the controllers module
    pub mod sms; // Make the sms module accessible
    pub mod mod.rs; // Ensure mod.rs is public and accessible in tests
}
#[cfg(test)] // Only include this part in test builds
mod tests; // Test module declaration
use crate::controllers::sms::send_sms; // Access the sms function from controllers
#[test] // Mark this function as a test
fn test_sms() {
    let result = send_sms("12345", "Test message");
    assert_eq!(result, Ok("Message sent successfully!")); // Validate test results
}

mod controllers; // Declare the module path for controllers
use controllers::sms; // Use the sms module from controllers
#[cfg(test)] // This module is only included during testing
mod test; // Test module declaration
#[test] // The test annotation for unit tests
fn test_send_sms() {
    let result = sms::send_sms("12345", "Hello, World!");
    assert_eq!(result, Ok("Message sent successfully!")); // Check for expected result
}
#[test] // Another test for failure case
fn test_send_sms_failure() {
    let result = sms::send_sms("", "");
    assert_eq!(result, Err("Invalid input")); // Expect failure case
}

పరీక్ష కోసం రస్ట్‌లో మాడ్యూల్‌లను ఎలా యాక్సెస్ చేయాలి మరియు స్ట్రక్చర్ చేయాలి

రస్ట్‌తో పని చేస్తున్నప్పుడు, మాడ్యూల్స్ ఎలా నిర్మాణాత్మకంగా ఉన్నాయి మరియు వాటిని ఎలా యాక్సెస్ చేయాలో అర్థం చేసుకోవడం అభివృద్ధి ప్రక్రియలో కీలకమైన భాగం. మీరు చైల్డ్ మాడ్యూల్‌ను యాక్సెస్ చేయాలనుకున్నప్పుడు ఇది చాలా ముఖ్యం వంటి ఫోల్డర్ లోపల , ఒక ప్రత్యేక ఫోల్డర్‌లో ఉన్న టెస్ట్ ఫైల్ నుండి . చైల్డ్ మాడ్యూల్‌లను విజయవంతంగా యాక్సెస్ చేయడం మరియు ఉపయోగించడంలో కీలకం రస్ట్ యొక్క మాడ్యూల్ సిస్టమ్‌ను అర్థం చేసుకోవడం, ఇది స్పష్టమైన మాడ్యూల్ డిక్లరేషన్‌లు మరియు సాపేక్ష మార్గాల ఉపయోగం రెండింటిపై ఆధారపడుతుంది. రస్ట్ ప్రతి ఫోల్డర్‌ని కలిగి ఉండే నిర్దిష్ట సోపానక్రమాన్ని ఉపయోగిస్తుంది mod.rs మాడ్యూల్ యొక్క పరిధిని నిర్వచించడానికి ఫైల్. ఈ మార్గాలను ఎలా సూచించాలో మీరు అర్థం చేసుకున్న తర్వాత, మీరు మీ కోడ్‌బేస్‌లోని వివిధ భాగాలను సమర్థవంతంగా పరీక్షించగలరు.

యాక్సెస్ చేయడానికి మీ పరీక్ష కోడ్‌లో ఫైల్ చేయండి, మీరు ముందుగా సోర్స్ కోడ్‌లో మాడ్యూల్ సరిగ్గా ప్రకటించబడిందని నిర్ధారించుకోవాలి. మా ఉదాహరణలో, ది ప్రధాన ప్రాజెక్ట్ డైరెక్టరీలోని స్టేట్‌మెంట్ ఫోల్డర్‌ను సూచించడంలో మాకు సహాయపడుతుంది mod.rs ఫైల్ ఉంది. పరీక్ష ఫైల్ లోపల, మీరు ఉపయోగించవచ్చు వంటి నిర్దిష్ట ఫైల్‌లను యాక్సెస్ చేయడానికి sms.rs మరియు దాని విధులు. ఈ మాడ్యులర్ నిర్మాణం మెరుగైన కోడ్ ఆర్గనైజేషన్ మరియు పునర్వినియోగాన్ని అనుమతిస్తుంది, ఎందుకంటే మీరు పరీక్ష కోసం అవసరమైన నిర్దిష్ట విధులు లేదా రకాలను మాత్రమే దిగుమతి చేసుకోవాలి.

రస్ట్ యొక్క మాడ్యూల్ సిస్టమ్ దృశ్యమానత గురించి చాలా కఠినంగా ఉందని గమనించడం ముఖ్యం. ఉదాహరణకు, మీరు వాటి అసలు మాడ్యూల్ వెలుపల ఉపయోగించాలనుకుంటున్న ఏవైనా విధులు లేదా రకాలు తప్పనిసరిగా దీనితో గుర్తించబడాలి వాటిని పబ్లిక్ చేయడానికి కీవర్డ్. ఈ సందర్భంలో, ది లోపల ఫంక్షన్ పరీక్ష ఫైల్‌లో యాక్సెస్ చేయడానికి ఫైల్ పబ్లిక్‌గా ఉండాలి. కోడ్‌బేస్‌లోని ఇతర భాగాలకు అవసరమైన భాగాలు మాత్రమే బహిర్గతమయ్యేలా చూసుకోవడం ద్వారా ఇది సిస్టమ్‌ను సురక్షితంగా మరియు పనితీరుగా చేస్తుంది. మీ మాడ్యూల్స్ మరియు పరీక్షలను సమర్థవంతంగా నిర్వహించడం ద్వారా, మీరు మీ రస్ట్ అప్లికేషన్ స్కేలబుల్ మరియు మెయింటెనబుల్‌గా ఉండేలా చూసుకోవచ్చు. ⚙️