റസ്റ്റ് ചൈൽഡ് മൊഡ്യൂളിൽ mod.rs ആക്‌സസ് ചെയ്യാൻ ഒരു ടെസ്റ്റ് ഫയൽ എങ്ങനെ ഉപയോഗിക്കാം

റസ്റ്റ് പ്രോജക്റ്റുകളിൽ മൊഡ്യൂൾ ആക്സസ് പര്യവേക്ഷണം ചെയ്യുന്നു

റസ്റ്റുമായി പ്രവർത്തിക്കുമ്പോൾ, വൃത്തിയുള്ളതും മോഡുലാർ കോഡും നിലനിർത്തുന്നതിന് മൊഡ്യൂളുകൾ എങ്ങനെ നിർമ്മിക്കാമെന്നും ആക്സസ് ചെയ്യാമെന്നും മനസ്സിലാക്കേണ്ടത് അത്യാവശ്യമാണ്. നിങ്ങൾ റസ്റ്റ് ഉപയോഗിച്ച് ആരംഭിക്കുകയാണെങ്കിലോ നിലവിലുള്ള ഒരു പ്രോജക്റ്റിൽ പ്രവർത്തിക്കുകയാണെങ്കിലോ, നിങ്ങളുടെ പ്രോജക്റ്റ് ഡയറക്‌ടറിയുടെ വിവിധ ഭാഗങ്ങളിൽ സ്ഥിതിചെയ്യുന്ന മൊഡ്യൂളുകൾ ആക്‌സസ് ചെയ്യുന്നതിനുള്ള വെല്ലുവിളി നിങ്ങൾക്ക് നേരിടേണ്ടി വന്നേക്കാം. പ്രധാന സോഴ്സ് കോഡിന് പുറത്തുള്ള ഒരു ടെസ്റ്റ് ഫയലിൽ നിന്ന് ഒരു ചൈൽഡ് മൊഡ്യൂൾ റഫറൻസ് ചെയ്യാൻ ശ്രമിക്കുമ്പോൾ, ഇത് ബുദ്ധിമുട്ടായിരിക്കും. 🔍

ഒരു റസ്റ്റ് പ്രോജക്റ്റിൻ്റെ പശ്ചാത്തലത്തിൽ, പ്രോജക്റ്റിൻ്റെ വിവിധ ഭാഗങ്ങളിൽ നിന്ന് ഒരു `mod.rs` ഫയൽ ആക്സസ് ചെയ്യാനുള്ള കഴിവ് ടെസ്റ്റിംഗിനും മോഡുലാരിറ്റിക്കും പ്രധാനമാണ്. `mod.rs` ഫയൽ ഒരു മൊഡ്യൂളിൻ്റെ എൻട്രി പോയിൻ്റായി പ്രവർത്തിക്കുന്നു, കൂടാതെ ഇത് ഒരു സബ്ഫോൾഡറിലെ ഉള്ളടക്കങ്ങൾ ക്രമീകരിക്കാൻ പലപ്പോഴും ഉപയോഗിക്കുന്നു. സ്റ്റാൻഡേർഡ് `src/` ഡയറക്‌ടറിക്ക് പുറത്തുള്ള `ടെസ്റ്റുകൾ/` ഫോൾഡറിൽ നിന്ന് ഈ ഫയൽ ആക്‌സസ് ചെയ്യാൻ ശ്രമിക്കുമ്പോൾ ഒരു പൊതു പ്രശ്നം ഉയർന്നുവരുന്നു. 🛠️

`src/` ഡയറക്‌ടറിക്കുള്ളിൽ നിങ്ങൾക്ക് ഒരു `കൺട്രോളറുകൾ/` ഫോൾഡറുള്ള ഒരു പ്രോജക്‌റ്റിലാണ് നിങ്ങൾ പ്രവർത്തിക്കുന്നതെന്ന് പറയാം, അതിൻ്റെ ചില പ്രവർത്തനക്ഷമത നിങ്ങൾക്ക് പരിശോധിക്കണം. `tests/test.rs` ഫയലിൽ നിന്ന് `mod.rs` ഫയൽ എങ്ങനെ ശരിയായി ഇറക്കുമതി ചെയ്യാമെന്നും ആക്‌സസ് ചെയ്യാമെന്നും അറിയുന്നത് നിങ്ങളുടെ ടെസ്റ്റിംഗ് പ്രക്രിയ സുഗമമാക്കും. എന്നിരുന്നാലും, ഇത് തടസ്സമില്ലാതെ നേടുന്നതിന് റസ്റ്റിൻ്റെ മൊഡ്യൂൾ സിസ്റ്റത്തിന് ആപേക്ഷിക പാതകളെക്കുറിച്ചും മൊഡ്യൂൾ ദൃശ്യപരതയെക്കുറിച്ചും നല്ല ധാരണ ആവശ്യമാണ്.

അടുത്ത വിഭാഗത്തിൽ, `test.rs` ഫയലിൽ നിന്ന് `കൺട്രോളേഴ്സ്` ഫോൾഡറിനുള്ളിലെ `mod.rs` ശരിയായി റഫറൻസ് ചെയ്തുകൊണ്ട് ഈ പ്രശ്നം പരിഹരിക്കാനുള്ള ഘട്ടങ്ങളിലൂടെ ഞങ്ങൾ പോകും. അവസാനത്തോടെ, ഈ വെല്ലുവിളി കൈകാര്യം ചെയ്യാനും നിങ്ങളുടെ റസ്റ്റ് പ്രോജക്റ്റുകൾക്കായി ഫലപ്രദമായ പരിശോധനകൾ നടപ്പിലാക്കാനും നിങ്ങൾ സജ്ജരാകും. ഈ പ്രക്രിയ വ്യക്തമാക്കുന്നതിന് നമുക്ക് ചില പ്രായോഗിക ഉദാഹരണങ്ങളിലേക്ക് കടക്കാം!

സ്ക്രിപ്റ്റ് മനസ്സിലാക്കുന്നു: റസ്റ്റിൽ ചൈൽഡ് മൊഡ്യൂളുകൾ ആക്സസ് ചെയ്യുന്നു

മുമ്പത്തെ ഉദാഹരണത്തിൽ, എങ്ങനെ ആക്സസ് ചെയ്യാമെന്ന് ഞങ്ങൾ പര്യവേക്ഷണം ചെയ്തു mod.rs ഉള്ളിലുള്ള ഫയൽ കൺട്രോളറുകൾ എന്നതിൽ സ്ഥിതിചെയ്യുന്ന ഒരു ടെസ്റ്റ് ഫയലിൽ നിന്നുള്ള ഫോൾഡർ പരിശോധനകൾ ഡയറക്ടറി. സ്ക്രിപ്റ്റുകൾ എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്നും ഓരോ ഭാഗവും പ്രധാനമായിരിക്കുന്നത് എന്തുകൊണ്ടാണെന്നും നമുക്ക് ആഴത്തിൽ നോക്കാം. നിങ്ങളുടെ റസ്റ്റ് പ്രോജക്റ്റിലെ മൊഡ്യൂളുകൾ പ്രഖ്യാപിക്കുകയാണ് ആദ്യ പടി, പ്രത്യേകിച്ച് മോഡ് പരാമർശിക്കാനുള്ള കീവേഡ് കൺട്രോളറുകൾ നിങ്ങളുടെ പ്രധാന കോഡ്ബേസിൽ നിന്നുള്ള മൊഡ്യൂൾ. ഇത് ഉള്ളടക്കത്തിൻ്റെ ഉള്ളടക്കം ഉണ്ടാക്കുന്നു കൺട്രോളറുകൾ ഫോൾഡർ, പോലുള്ളവ sms.rs, ടെസ്റ്റുകൾ ഉൾപ്പെടെ നിങ്ങളുടെ ബാക്കി കോഡിലേക്ക് ആക്‌സസ് ചെയ്യാനാകും. ഈ പ്രഖ്യാപനം കൂടാതെ, നിങ്ങളുടെ ടെസ്റ്റ് ഫയലുകൾക്ക് മൊഡ്യൂൾ കണ്ടെത്താനോ ഉപയോഗിക്കാനോ കഴിയില്ല. ഇത് ഒരു സ്ഥലത്തിന് വ്യക്തമായ വിലാസം നൽകുന്നത് പോലെയാണ്-അതില്ലാതെ, എവിടേക്ക് പോകണമെന്ന് സിസ്റ്റത്തിന് അറിയില്ല. 🛠️

ഈ സ്ക്രിപ്റ്റുകളുടെ മറ്റൊരു പ്രധാന വശം ഇതിൻ്റെ ഉപയോഗമാണ് #[cfg(ടെസ്റ്റ്)] ആട്രിബ്യൂട്ട്. ടെസ്റ്റിംഗ് സമയത്ത് മാത്രം കോഡിൻ്റെ പ്രത്യേക ഭാഗങ്ങൾ കംപൈൽ ചെയ്യാനും ഉൾപ്പെടുത്താനും ഈ ആട്രിബ്യൂട്ട് റസ്റ്റിനോട് പറയുന്നു. ഞങ്ങളുടെ കാര്യത്തിൽ, ടെസ്റ്റ് ഫംഗ്‌ഷനുകൾ ഒറ്റപ്പെടുത്താൻ ഇത് ഉപയോഗിക്കുന്നു, അതിനാൽ അവ ആപ്ലിക്കേഷൻ്റെ പ്രധാന യുക്തിയെ ബാധിക്കില്ല. ഈ സമീപനം ശുദ്ധമായ കോഡ് നിലനിർത്തുന്നതിനും ലോജിക് ടെസ്റ്റിംഗ് പ്രൊഡക്ഷൻ കോഡിൽ ഇടപെടുന്നില്ലെന്ന് ഉറപ്പാക്കുന്നതിനും സഹായിക്കുന്നു. സിസ്റ്റത്തിൻ്റെ പ്രകടനമോ പ്രവർത്തനമോ പരിശോധിക്കാൻ നിങ്ങൾ തയ്യാറാകുമ്പോൾ മാത്രം പ്രവർത്തനക്ഷമമാകുന്ന ഒരു ടെസ്റ്റ് എൻവയോൺമെൻ്റ് ഉള്ളതുപോലെ നിങ്ങൾക്ക് ഇതിനെക്കുറിച്ച് ചിന്തിക്കാനാകും. ഇത് സിസ്റ്റം സ്ഥിരതയുള്ളതും പരീക്ഷണ പ്രവർത്തനങ്ങളാൽ ബാധിക്കപ്പെടാത്തതും ഉറപ്പാക്കുന്നു.

ദി ഉപയോഗിക്കുക നിർദ്ദിഷ്ട മൊഡ്യൂളുകളോ ഫംഗ്‌ഷനുകളോ വ്യാപ്തിയിലേക്ക് കൊണ്ടുവരുന്നതിൽ കീവേഡ് നിർണായക പങ്ക് വഹിക്കുന്നു. തിരക്കഥയിൽ, കൺട്രോളറുകൾ ഉപയോഗിക്കുക ::sms ആക്സസ് ചെയ്യാൻ ഞങ്ങളെ അനുവദിക്കുന്നു sms.rs ഉള്ളിലെ മൊഡ്യൂൾ കൺട്രോളറുകൾ ടെസ്റ്റ് ഫയലിൽ നിന്നുള്ള ഫോൾഡർ. ഇത് എല്ലാ പൊതു പ്രവർത്തനങ്ങളും ഉള്ളിലാക്കുന്നു sms.rs ആക്സസ് ചെയ്യാവുന്നത് പോലെ അയയ്ക്കുക_sms ഫംഗ്‌ഷൻ, അത് പ്രതീക്ഷിച്ചതുപോലെ പ്രവർത്തിക്കുന്നുണ്ടോയെന്ന് പരിശോധിക്കാൻ ഞങ്ങൾ പരിശോധിക്കുന്നു. കോഡ് പുനരുപയോഗക്ഷമതയ്ക്കും മോഡുലാരിറ്റിക്കുമായി റസ്റ്റിൽ ഈ സമീപനം ഒരു സാധാരണ പാറ്റേണാണ്. നിങ്ങൾ ഒരു ലൈബ്രറിയിലാണെന്ന് സങ്കൽപ്പിക്കുക, ഒപ്പം ഉപയോഗിക്കുക നിങ്ങളുടെ ജോലി പൂർത്തിയാക്കാൻ ഷെൽഫിൽ നിന്ന് ആവശ്യമുള്ള ഒരു പ്രത്യേക പുസ്തകം ലഭിക്കുന്നത് പോലെയാണ് ഇത് - കോഡിൻ്റെ പ്രസക്ത ഭാഗങ്ങൾ മാത്രം നിങ്ങൾക്ക് ലഭ്യമാക്കുന്നതിലൂടെ സമയവും പരിശ്രമവും ലാഭിക്കുന്നു. 📚

ഒടുവിൽ, ദി #[ടെസ്റ്റ്] വ്യാഖ്യാനവും assert_eq! ഞങ്ങളുടെ യൂണിറ്റ് ടെസ്റ്റുകൾ പ്രവർത്തിപ്പിക്കുന്നതിനും സാധൂകരിക്കുന്നതിനും മാക്രോ അത്യാവശ്യമാണ്. #[ടെസ്റ്റ്] ഒരു ഫംഗ്‌ഷനെ ഒരു ടെസ്റ്റ് കേസായി അടയാളപ്പെടുത്തുന്നു, അത് റസ്റ്റ് ടെസ്റ്റ് ഫ്രെയിംവർക്ക് സ്വയമേവ തിരിച്ചറിയുന്നു. സ്ക്രിപ്റ്റിൽ, ഞങ്ങൾ ഉപയോഗിച്ചു assert_eq! പ്രതീക്ഷിക്കുന്ന ഫലത്തെ യഥാർത്ഥ ഫലവുമായി താരതമ്യം ചെയ്യാൻ അയയ്ക്കുക_sms പ്രവർത്തനം. മൂല്യങ്ങൾ പൊരുത്തപ്പെടുന്നില്ലെങ്കിൽ, പരിശോധന പരാജയപ്പെടും, ഇത് ഞങ്ങളുടെ കോഡിൻ്റെ പ്രവർത്തനത്തെക്കുറിച്ച് ഉടനടി ഫീഡ്‌ബാക്ക് നൽകും. ഞങ്ങളുടെ മൊഡ്യൂളുകൾ പ്രതീക്ഷിച്ചതുപോലെ പ്രവർത്തിക്കുന്നുവെന്ന് ഉറപ്പാക്കാൻ ഇത് ഞങ്ങളെ സഹായിക്കുന്നു, പ്രശ്നങ്ങൾ പെട്ടെന്ന് തിരിച്ചറിയാനും പരിഹരിക്കാനും ഞങ്ങളെ അനുവദിക്കുന്നു. വികസന വേളയിൽ ഒരു സുരക്ഷാ വലയം ഉള്ളതുപോലെയാണ് ഇത്—എന്തെങ്കിലും തെറ്റ് സംഭവിച്ചാൽ, പരിശോധന അത് പിടിക്കുകയും എവിടെയാണ് നോക്കേണ്ടതെന്ന് കൃത്യമായി ഞങ്ങളോട് പറയുകയും ചെയ്യും.

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 പോലുള്ള ഒരു ഫോൾഡറിനുള്ളിൽ കൺട്രോളറുകൾ, ഒരു പ്രത്യേക ഫോൾഡറിൽ സ്ഥിതി ചെയ്യുന്ന ഒരു ടെസ്റ്റ് ഫയലിൽ നിന്ന് പരിശോധനകൾ. ചൈൽഡ് മൊഡ്യൂളുകൾ വിജയകരമായി ആക്‌സസ് ചെയ്യുന്നതിനും ഉപയോഗിക്കുന്നതിനുമുള്ള താക്കോൽ റസ്റ്റിൻ്റെ മൊഡ്യൂൾ സിസ്റ്റം മനസ്സിലാക്കുക എന്നതാണ്, ഇത് വ്യക്തമായ മൊഡ്യൂൾ പ്രഖ്യാപനങ്ങളെയും ആപേക്ഷിക പാതകളുടെ ഉപയോഗത്തെയും ആശ്രയിച്ചിരിക്കുന്നു. റസ്റ്റ് ഒരു പ്രത്യേക ശ്രേണി ഉപയോഗിക്കുന്നു, അവിടെ ഓരോ ഫോൾഡറും a അടങ്ങിയിരിക്കാം mod.rs മൊഡ്യൂളിൻ്റെ വ്യാപ്തി നിർവചിക്കുന്നതിനുള്ള ഫയൽ. ഈ പാതകൾ എങ്ങനെ പരാമർശിക്കണമെന്ന് നിങ്ങൾ മനസ്സിലാക്കിക്കഴിഞ്ഞാൽ, നിങ്ങളുടെ കോഡ്ബേസിൻ്റെ വിവിധ ഭാഗങ്ങൾ കാര്യക്ഷമമായി പരീക്ഷിക്കാൻ നിങ്ങൾക്ക് കഴിയും.

ആക്സസ് ചെയ്യാൻ mod.rs നിങ്ങളുടെ ടെസ്റ്റ് കോഡിൽ ഫയൽ ചെയ്യുക, സോഴ്സ് കോഡിൽ മൊഡ്യൂൾ ശരിയായി പ്രഖ്യാപിച്ചിട്ടുണ്ടെന്ന് നിങ്ങൾ ആദ്യം ഉറപ്പാക്കേണ്ടതുണ്ട്. ഞങ്ങളുടെ ഉദാഹരണത്തിൽ, ദി mod controllers പ്രധാന പ്രോജക്റ്റ് ഡയറക്‌ടറിയിലെ പ്രസ്താവന, ഫോൾഡർ റഫറൻസ് ചെയ്യാൻ ഞങ്ങളെ സഹായിക്കുന്നു mod.rs ഫയൽ സ്ഥിതിചെയ്യുന്നു. ടെസ്റ്റ് ഫയലിനുള്ളിൽ, നിങ്ങൾക്ക് പിന്നീട് ഉപയോഗിക്കാം use crate::controllers::sms പോലുള്ള നിർദ്ദിഷ്ട ഫയലുകൾ ആക്സസ് ചെയ്യാൻ sms.rs അതിൻ്റെ പ്രവർത്തനങ്ങളും. ഈ മോഡുലാർ ഘടന മെച്ചപ്പെട്ട കോഡ് ഓർഗനൈസേഷനും പുനരുപയോഗക്ഷമതയും അനുവദിക്കുന്നു, കാരണം നിങ്ങൾ ടെസ്റ്റിംഗിന് ആവശ്യമായ നിർദ്ദിഷ്ട ഫംഗ്ഷനുകളോ തരങ്ങളോ മാത്രമേ ഇറക്കുമതി ചെയ്യാവൂ.

റസ്റ്റിൻ്റെ മൊഡ്യൂൾ സംവിധാനം ദൃശ്യപരതയെക്കുറിച്ച് വളരെ കർശനമാണ് എന്നത് ശ്രദ്ധിക്കേണ്ടതാണ്. ഉദാഹരണത്തിന്, നിങ്ങൾ അവയുടെ യഥാർത്ഥ മൊഡ്യൂളിന് പുറത്ത് ഉപയോഗിക്കാൻ ആഗ്രഹിക്കുന്ന ഏതെങ്കിലും ഫംഗ്ഷനുകളോ തരങ്ങളോ ഉപയോഗിച്ച് അടയാളപ്പെടുത്തിയിരിക്കണം pub അവ പരസ്യമാക്കുന്നതിനുള്ള കീവേഡ്. ഈ സാഹചര്യത്തിൽ, ദി sms::send_sms അകത്തുള്ള പ്രവർത്തനം sms.rs ടെസ്റ്റ് ഫയലിൽ ആക്‌സസ് ചെയ്യുന്നതിന് ഫയൽ പൊതുവായിരിക്കണം. കോഡ്ബേസിൻ്റെ മറ്റ് ഭാഗങ്ങളിലേക്ക് ആവശ്യമായ ഘടകങ്ങൾ മാത്രം തുറന്നുകാട്ടുന്നത് ഉറപ്പാക്കിക്കൊണ്ട് ഇത് സിസ്റ്റത്തെ സുരക്ഷിതവും പ്രവർത്തനക്ഷമവുമാക്കുന്നു. നിങ്ങളുടെ മൊഡ്യൂളുകളും ടെസ്റ്റുകളും ഫലപ്രദമായി സംഘടിപ്പിക്കുന്നതിലൂടെ, നിങ്ങളുടെ റസ്റ്റ് ആപ്ലിക്കേഷൻ അളക്കാവുന്നതും പരിപാലിക്കാവുന്നതുമാണെന്ന് ഉറപ്പാക്കാൻ കഴിയും. ⚙️