ਰਸਟ ਚਾਈਲਡ ਮੋਡੀਊਲ ਵਿੱਚ mod.rs ਤੱਕ ਪਹੁੰਚ ਕਰਨ ਲਈ ਇੱਕ ਟੈਸਟ ਫਾਈਲ ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕਰੀਏ

ਜੰਗਾਲ ਪ੍ਰੋਜੈਕਟਾਂ ਵਿੱਚ ਮੋਡੀਊਲ ਪਹੁੰਚ ਦੀ ਪੜਚੋਲ ਕਰਨਾ

Rust ਦੇ ਨਾਲ ਕੰਮ ਕਰਦੇ ਸਮੇਂ, ਸਾਫ਼ ਅਤੇ ਮਾਡਿਊਲਰ ਕੋਡ ਨੂੰ ਬਣਾਈ ਰੱਖਣ ਲਈ ਮੋਡੀਊਲ ਦੀ ਬਣਤਰ ਅਤੇ ਐਕਸੈਸ ਕਰਨ ਦੇ ਤਰੀਕੇ ਨੂੰ ਸਮਝਣਾ ਜ਼ਰੂਰੀ ਹੈ। ਜੇਕਰ ਤੁਸੀਂ ਹੁਣੇ ਹੀ Rust ਨਾਲ ਸ਼ੁਰੂਆਤ ਕਰ ਰਹੇ ਹੋ ਜਾਂ ਕਿਸੇ ਮੌਜੂਦਾ ਪ੍ਰੋਜੈਕਟ 'ਤੇ ਕੰਮ ਕਰ ਰਹੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ ਆਪਣੀ ਪ੍ਰੋਜੈਕਟ ਡਾਇਰੈਕਟਰੀ ਦੇ ਵੱਖ-ਵੱਖ ਹਿੱਸਿਆਂ ਵਿੱਚ ਸਥਿਤ ਮੈਡਿਊਲਾਂ ਤੱਕ ਪਹੁੰਚ ਕਰਨ ਦੀ ਚੁਣੌਤੀ ਦਾ ਸਾਹਮਣਾ ਕਰਨਾ ਪੈ ਸਕਦਾ ਹੈ। ਇਹ ਔਖਾ ਹੋ ਸਕਦਾ ਹੈ, ਖਾਸ ਤੌਰ 'ਤੇ ਜਦੋਂ ਮੁੱਖ ਸਰੋਤ ਕੋਡ ਤੋਂ ਬਾਹਰ ਕਿਸੇ ਟੈਸਟ ਫਾਈਲ ਤੋਂ ਚਾਈਲਡ ਮੋਡਿਊਲ ਦਾ ਹਵਾਲਾ ਦੇਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। 🔍

ਇੱਕ ਜੰਗਾਲ ਪ੍ਰੋਜੈਕਟ ਦੇ ਸੰਦਰਭ ਵਿੱਚ, ਪ੍ਰੋਜੈਕਟ ਦੇ ਵੱਖ-ਵੱਖ ਹਿੱਸਿਆਂ ਤੋਂ ਇੱਕ `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]	ਕਿਸੇ ਫੰਕਸ਼ਨ ਨੂੰ ਯੂਨਿਟ ਟੈਸਟ ਵਜੋਂ ਚਿੰਨ੍ਹਿਤ ਕਰਦਾ ਹੈ। Rust ਦਾ ਬਿਲਟ-ਇਨ ਟੈਸਟ ਫਰੇਮਵਰਕ ਟੈਸਟਾਂ ਦੇ ਤੌਰ ਤੇ ਚਲਾਉਣ ਲਈ ਫੰਕਸ਼ਨਾਂ ਦੀ ਪਛਾਣ ਕਰਨ ਲਈ ਇਸ ਐਨੋਟੇਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ, ਉਦਾਹਰਨ ਲਈ, #[test] fn test_sms().
assert_eq!	ਇਹ ਜਾਂਚ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ ਕਿ ਕੀ ਦੋ ਸਮੀਕਰਨ ਇੱਕੋ ਮੁੱਲ ਦਾ ਮੁਲਾਂਕਣ ਕਰਦੇ ਹਨ। ਜੇਕਰ ਮੁੱਲ ਬਰਾਬਰ ਨਹੀਂ ਹਨ, ਤਾਂ ਟੈਸਟ ਅਸਫਲ ਹੋ ਜਾਂਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, assert_eq!(ਨਤੀਜਾ, Ok("ਸੁਨੇਹਾ ਸਫਲਤਾਪੂਰਵਕ ਭੇਜਿਆ ਗਿਆ!")); ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਨਤੀਜਾ ਉਮੀਦ ਕੀਤੀ ਆਉਟਪੁੱਟ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ।
Err	Rust ਵਿੱਚ ਨਤੀਜਾ ਕਿਸਮ ਦੇ ਇੱਕ ਰੂਪ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ, ਇੱਕ ਗਲਤੀ ਜਾਂ ਅਸਫਲਤਾ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ। ਇਹ ਟੈਸਟ ਕੇਸ ਵਿੱਚ ਇੱਕ ਅਸਫਲ ਸਥਿਤੀ ਦੀ ਨਕਲ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ Err("ਅਵੈਧ ਇਨਪੁਟ") ਵਿੱਚ ਦੇਖਿਆ ਗਿਆ ਹੈ।
Ok	ਨਤੀਜਾ ਕਿਸਮ ਦੇ ਸਫਲਤਾ ਰੂਪ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ। ਇਹ ਇੱਕ ਸਫਲ ਨਤੀਜੇ ਦੀ ਨਕਲ ਕਰਨ ਲਈ ਟੈਸਟਾਂ ਵਿੱਚ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ Ok("ਸੁਨੇਹਾ ਸਫਲਤਾਪੂਰਵਕ ਭੇਜਿਆ ਗਿਆ!")।
mod.rs	ਫਾਈਲ ਨਾਮ ਜੋ ਕਿ Rust ਇੱਕ ਡਾਇਰੈਕਟਰੀ ਲਈ ਇੱਕ ਮੋਡੀਊਲ ਘੋਸ਼ਿਤ ਕਰਨ ਲਈ ਵਰਤਦਾ ਹੈ। ਇਹ ਉਸੇ ਫੋਲਡਰ ਦੇ ਅੰਦਰ ਸਬਮੋਡਿਊਲਾਂ ਨੂੰ ਸੰਗਠਿਤ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ, ਜਦੋਂ ਤੁਸੀਂ ਮੂਲ ਫੋਲਡਰ ਦਾ ਹਵਾਲਾ ਦਿੰਦੇ ਹੋ, ਉਦਾਹਰਨ ਲਈ, ਮਾਡ ਕੰਟਰੋਲਰ; `controllers/mod.rs` ਤੱਕ ਪਹੁੰਚ ਕਰਦਾ ਹੈ।

ਸਕ੍ਰਿਪਟ ਨੂੰ ਸਮਝਣਾ: ਜੰਗਾਲ ਵਿੱਚ ਬਾਲ ਮਾਡਿਊਲਾਂ ਤੱਕ ਪਹੁੰਚਣਾ

ਪਿਛਲੀ ਉਦਾਹਰਨ ਵਿੱਚ, ਅਸੀਂ ਖੋਜ ਕੀਤੀ ਹੈ ਕਿ ਕਿਵੇਂ ਪਹੁੰਚ ਕਰਨੀ ਹੈ ਦੇ ਅੰਦਰ ਫਾਈਲ ਵਿੱਚ ਸਥਿਤ ਇੱਕ ਟੈਸਟ ਫਾਈਲ ਤੋਂ ਫੋਲਡਰ ਡਾਇਰੈਕਟਰੀ. ਆਉ ਇਸ ਗੱਲ ਵਿੱਚ ਡੂੰਘਾਈ ਨਾਲ ਡੁਬਕੀ ਕਰੀਏ ਕਿ ਸਕ੍ਰਿਪਟਾਂ ਕਿਵੇਂ ਕੰਮ ਕਰਦੀਆਂ ਹਨ ਅਤੇ ਹਰੇਕ ਭਾਗ ਮਹੱਤਵਪੂਰਨ ਕਿਉਂ ਹੈ। ਪਹਿਲਾ ਕਦਮ ਤੁਹਾਡੇ ਜੰਗਾਲ ਪ੍ਰੋਜੈਕਟ ਵਿੱਚ ਮੋਡਿਊਲਾਂ ਦੀ ਘੋਸ਼ਣਾ ਕਰ ਰਿਹਾ ਹੈ, ਖਾਸ ਤੌਰ 'ਤੇ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਮਾਡ ਦਾ ਹਵਾਲਾ ਦੇਣ ਲਈ ਕੀਵਰਡ ਕੰਟਰੋਲਰ ਤੁਹਾਡੇ ਮੁੱਖ ਕੋਡਬੇਸ ਤੋਂ ਮੋਡੀਊਲ। ਇਹ ਦੀ ਸਮੱਗਰੀ ਬਣਾਉਂਦਾ ਹੈ ਕੰਟਰੋਲਰ ਫੋਲਡਰ, ਜਿਵੇਂ ਕਿ , ਟੈਸਟਾਂ ਸਮੇਤ, ਤੁਹਾਡੇ ਬਾਕੀ ਕੋਡ ਤੱਕ ਪਹੁੰਚਯੋਗ। ਇਸ ਘੋਸ਼ਣਾ ਤੋਂ ਬਿਨਾਂ, ਤੁਹਾਡੀਆਂ ਟੈਸਟ ਫਾਈਲਾਂ ਮੋਡੀਊਲ ਨੂੰ ਲੱਭਣ ਜਾਂ ਵਰਤਣ ਦੇ ਯੋਗ ਨਹੀਂ ਹੋਣਗੀਆਂ। ਇਹ ਕਿਸੇ ਟਿਕਾਣੇ ਲਈ ਸਪਸ਼ਟ ਪਤਾ ਪ੍ਰਦਾਨ ਕਰਨ ਵਰਗਾ ਹੈ—ਇਸਦੇ ਬਿਨਾਂ, ਸਿਸਟਮ ਇਹ ਨਹੀਂ ਜਾਣ ਸਕਦਾ ਕਿ ਕਿੱਥੇ ਜਾਣਾ ਹੈ। 🛠️

ਇਹਨਾਂ ਸਕ੍ਰਿਪਟਾਂ ਦਾ ਇੱਕ ਹੋਰ ਮੁੱਖ ਪਹਿਲੂ ਹੈ ਦੀ ਵਰਤੋਂ ਵਿਸ਼ੇਸ਼ਤਾ. ਇਹ ਵਿਸ਼ੇਸ਼ਤਾ Rust ਨੂੰ ਕੰਪਾਇਲ ਕਰਨ ਅਤੇ ਕੋਡ ਦੇ ਖਾਸ ਭਾਗਾਂ ਨੂੰ ਸਿਰਫ਼ ਟੈਸਟਿੰਗ ਦੌਰਾਨ ਸ਼ਾਮਲ ਕਰਨ ਲਈ ਕਹਿੰਦੀ ਹੈ। ਸਾਡੇ ਕੇਸ ਵਿੱਚ, ਇਸਦੀ ਵਰਤੋਂ ਟੈਸਟ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਅਲੱਗ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਇਸਲਈ ਉਹ ਐਪਲੀਕੇਸ਼ਨ ਦੇ ਮੁੱਖ ਤਰਕ ਨੂੰ ਪ੍ਰਭਾਵਤ ਨਹੀਂ ਕਰਦੇ ਹਨ। ਇਹ ਪਹੁੰਚ ਸਾਫ਼ ਕੋਡ ਨੂੰ ਬਣਾਈ ਰੱਖਣ ਅਤੇ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਵਿੱਚ ਮਦਦ ਕਰਦੀ ਹੈ ਕਿ ਟੈਸਟਿੰਗ ਤਰਕ ਉਤਪਾਦਨ ਕੋਡ ਵਿੱਚ ਦਖ਼ਲ ਨਹੀਂ ਦਿੰਦਾ ਹੈ। ਤੁਸੀਂ ਇਸ ਬਾਰੇ ਸੋਚ ਸਕਦੇ ਹੋ ਜਿਵੇਂ ਇੱਕ ਟੈਸਟ ਵਾਤਾਵਰਨ ਹੋਣਾ ਜੋ ਸਿਰਫ਼ ਉਦੋਂ ਕਿਰਿਆਸ਼ੀਲ ਹੁੰਦਾ ਹੈ ਜਦੋਂ ਤੁਸੀਂ ਸਿਸਟਮ ਦੀ ਕਾਰਗੁਜ਼ਾਰੀ ਜਾਂ ਕਾਰਜਕੁਸ਼ਲਤਾ ਦੀ ਜਾਂਚ ਕਰਨ ਲਈ ਤਿਆਰ ਹੁੰਦੇ ਹੋ। ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਸਿਸਟਮ ਸਥਿਰ ਰਹੇ ਅਤੇ ਟੈਸਟਿੰਗ ਓਪਰੇਸ਼ਨਾਂ ਦੁਆਰਾ ਪ੍ਰਭਾਵਿਤ ਨਹੀਂ ਹੁੰਦਾ।

ਦ ਕੀਵਰਡ ਖਾਸ ਮੋਡੀਊਲਾਂ ਜਾਂ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਦਾਇਰੇ ਵਿੱਚ ਲਿਆਉਣ ਵਿੱਚ ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਭੂਮਿਕਾ ਨਿਭਾਉਂਦਾ ਹੈ। ਸਕ੍ਰਿਪਟ ਵਿੱਚ, ਤੱਕ ਪਹੁੰਚ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ ਦੇ ਅੰਦਰ ਮੋਡੀਊਲ ਕੰਟਰੋਲਰ ਟੈਸਟ ਫਾਈਲ ਤੋਂ ਫੋਲਡਰ. ਇਹ ਸਾਰੇ ਜਨਤਕ ਕਾਰਜਾਂ ਨੂੰ ਅੰਦਰ ਬਣਾਉਂਦਾ ਹੈ ਪਹੁੰਚਯੋਗ, ਜਿਵੇਂ ਕਿ ਫੰਕਸ਼ਨ, ਜਿਸ ਨੂੰ ਅਸੀਂ ਫਿਰ ਇਹ ਪੁਸ਼ਟੀ ਕਰਨ ਲਈ ਟੈਸਟ ਕਰਦੇ ਹਾਂ ਕਿ ਕੀ ਇਹ ਉਮੀਦ ਅਨੁਸਾਰ ਕੰਮ ਕਰਦਾ ਹੈ। ਇਹ ਪਹੁੰਚ ਕੋਡ ਦੀ ਮੁੜ ਵਰਤੋਂਯੋਗਤਾ ਅਤੇ ਮਾਡਿਊਲਰਿਟੀ ਲਈ ਜੰਗਾਲ ਵਿੱਚ ਇੱਕ ਆਮ ਪੈਟਰਨ ਹੈ। ਕਲਪਨਾ ਕਰੋ ਕਿ ਤੁਸੀਂ ਇੱਕ ਲਾਇਬ੍ਰੇਰੀ ਵਿੱਚ ਹੋ, ਅਤੇ ਇਹ ਤੁਹਾਡੇ ਕੰਮ ਨੂੰ ਪੂਰਾ ਕਰਨ ਲਈ ਸ਼ੈਲਫ ਤੋਂ ਇੱਕ ਖਾਸ ਕਿਤਾਬ ਪ੍ਰਾਪਤ ਕਰਨ ਵਰਗਾ ਹੈ-ਇਹ ਤੁਹਾਡੇ ਲਈ ਕੋਡ ਦੇ ਸਿਰਫ਼ ਸੰਬੰਧਿਤ ਹਿੱਸਿਆਂ ਨੂੰ ਉਪਲਬਧ ਕਰਵਾ ਕੇ ਸਮਾਂ ਅਤੇ ਮਿਹਨਤ ਦੀ ਬਚਤ ਕਰਦਾ ਹੈ। 📚

ਅੰਤ ਵਿੱਚ, ਦ ਐਨੋਟੇਸ਼ਨ ਅਤੇ ਸਾਡੇ ਯੂਨਿਟ ਟੈਸਟਾਂ ਨੂੰ ਚਲਾਉਣ ਅਤੇ ਪ੍ਰਮਾਣਿਤ ਕਰਨ ਲਈ ਮੈਕਰੋ ਜ਼ਰੂਰੀ ਹਨ। ਇੱਕ ਫੰਕਸ਼ਨ ਨੂੰ ਇੱਕ ਟੈਸਟ ਕੇਸ ਦੇ ਰੂਪ ਵਿੱਚ ਚਿੰਨ੍ਹਿਤ ਕਰਦਾ ਹੈ, ਜੋ ਕਿ ਜੰਗਾਲ ਟੈਸਟ ਫਰੇਮਵਰਕ ਦੁਆਰਾ ਆਪਣੇ ਆਪ ਪਛਾਣਿਆ ਜਾਂਦਾ ਹੈ। ਸਕ੍ਰਿਪਟ ਵਿੱਚ, ਅਸੀਂ ਵਰਤਿਆ 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
}

ਟੈਸਟਿੰਗ ਲਈ ਜੰਗਾਲ ਵਿੱਚ ਮੋਡੀਊਲ ਤੱਕ ਪਹੁੰਚ ਅਤੇ ਢਾਂਚਾ ਕਿਵੇਂ ਕਰਨਾ ਹੈ

Rust ਨਾਲ ਕੰਮ ਕਰਦੇ ਸਮੇਂ, ਇਹ ਸਮਝਣਾ ਕਿ ਮੋਡੀਊਲ ਕਿਵੇਂ ਬਣਤਰ ਹਨ ਅਤੇ ਉਹਨਾਂ ਤੱਕ ਕਿਵੇਂ ਪਹੁੰਚਣਾ ਹੈ ਵਿਕਾਸ ਪ੍ਰਕਿਰਿਆ ਦਾ ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਹਿੱਸਾ ਹੈ। ਇਹ ਖਾਸ ਤੌਰ 'ਤੇ ਮਹੱਤਵਪੂਰਨ ਹੁੰਦਾ ਹੈ ਜਦੋਂ ਤੁਸੀਂ ਕਿਸੇ ਚਾਈਲਡ ਮੋਡੀਊਲ ਨੂੰ ਐਕਸੈਸ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਜਿਵੇਂ ਕਿ ਵਰਗੇ ਫੋਲਡਰ ਦੇ ਅੰਦਰ , ਇੱਕ ਵੱਖਰੇ ਫੋਲਡਰ ਵਿੱਚ ਸਥਿਤ ਇੱਕ ਟੈਸਟ ਫਾਈਲ ਤੋਂ, ਜਿਵੇਂ ਕਿ . ਚਾਈਲਡ ਮੋਡੀਊਲ ਨੂੰ ਸਫਲਤਾਪੂਰਵਕ ਐਕਸੈਸ ਕਰਨ ਅਤੇ ਵਰਤਣ ਦੀ ਕੁੰਜੀ ਰਸਟ ਦੇ ਮੋਡੀਊਲ ਸਿਸਟਮ ਨੂੰ ਸਮਝਣਾ ਹੈ, ਜੋ ਕਿ ਸਪੱਸ਼ਟ ਮੋਡੀਊਲ ਘੋਸ਼ਣਾਵਾਂ ਅਤੇ ਸੰਬੰਧਿਤ ਮਾਰਗਾਂ ਦੀ ਵਰਤੋਂ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ। ਜੰਗਾਲ ਇੱਕ ਖਾਸ ਲੜੀ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ ਜਿੱਥੇ ਹਰੇਕ ਫੋਲਡਰ ਵਿੱਚ ਏ mod.rs ਮੋਡੀਊਲ ਦੇ ਦਾਇਰੇ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਲਈ ਫਾਈਲ. ਇੱਕ ਵਾਰ ਜਦੋਂ ਤੁਸੀਂ ਇਹ ਸਮਝ ਲੈਂਦੇ ਹੋ ਕਿ ਇਹਨਾਂ ਮਾਰਗਾਂ ਦਾ ਹਵਾਲਾ ਕਿਵੇਂ ਦੇਣਾ ਹੈ, ਤਾਂ ਤੁਸੀਂ ਆਪਣੇ ਕੋਡਬੇਸ ਦੇ ਵੱਖ-ਵੱਖ ਹਿੱਸਿਆਂ ਦੀ ਕੁਸ਼ਲਤਾ ਨਾਲ ਜਾਂਚ ਕਰਨ ਦੇ ਯੋਗ ਹੋਵੋਗੇ।

ਤੱਕ ਪਹੁੰਚ ਕਰਨ ਲਈ ਤੁਹਾਡੇ ਟੈਸਟ ਕੋਡ ਵਿੱਚ ਫਾਈਲ, ਤੁਹਾਨੂੰ ਪਹਿਲਾਂ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਦੀ ਲੋੜ ਪਵੇਗੀ ਕਿ ਮੋਡੀਊਲ ਨੂੰ ਸਰੋਤ ਕੋਡ ਵਿੱਚ ਸਹੀ ਢੰਗ ਨਾਲ ਘੋਸ਼ਿਤ ਕੀਤਾ ਗਿਆ ਹੈ। ਸਾਡੀ ਉਦਾਹਰਨ ਵਿੱਚ, ਦ ਮੁੱਖ ਪ੍ਰੋਜੈਕਟ ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਬਿਆਨ ਸਾਨੂੰ ਫੋਲਡਰ ਦਾ ਹਵਾਲਾ ਦੇਣ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ ਜਿੱਥੇ mod.rs ਫਾਈਲ ਸਥਿਤ ਹੈ। ਟੈਸਟ ਫਾਈਲ ਦੇ ਅੰਦਰ, ਤੁਸੀਂ ਫਿਰ ਵਰਤ ਸਕਦੇ ਹੋ ਖਾਸ ਫਾਈਲਾਂ ਜਿਵੇਂ ਕਿ ਐਕਸੈਸ ਕਰਨ ਲਈ sms.rs ਅਤੇ ਇਸ ਦੇ ਕਾਰਜ। ਇਹ ਮਾਡਯੂਲਰ ਢਾਂਚਾ ਬਿਹਤਰ ਕੋਡ ਸੰਗਠਨ ਅਤੇ ਮੁੜ ਵਰਤੋਂਯੋਗਤਾ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ, ਕਿਉਂਕਿ ਤੁਹਾਨੂੰ ਸਿਰਫ਼ ਟੈਸਟਿੰਗ ਲਈ ਲੋੜੀਂਦੇ ਖਾਸ ਫੰਕਸ਼ਨਾਂ ਜਾਂ ਕਿਸਮਾਂ ਨੂੰ ਆਯਾਤ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।

ਇਹ ਨੋਟ ਕਰਨਾ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿ ਜੰਗਾਲ ਦਾ ਮੋਡਿਊਲ ਸਿਸਟਮ ਦਿੱਖ ਬਾਰੇ ਬਹੁਤ ਸਖ਼ਤ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਕੋਈ ਵੀ ਫੰਕਸ਼ਨ ਜਾਂ ਕਿਸਮ ਜੋ ਤੁਸੀਂ ਉਹਨਾਂ ਦੇ ਮੂਲ ਮੋਡੀਊਲ ਤੋਂ ਬਾਹਰ ਵਰਤਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਉਹਨਾਂ ਨੂੰ ਨਾਲ ਚਿੰਨ੍ਹਿਤ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ ਉਹਨਾਂ ਨੂੰ ਜਨਤਕ ਕਰਨ ਲਈ ਕੀਵਰਡ. ਇਸ ਮਾਮਲੇ ਵਿੱਚ, ਦ ਦੇ ਅੰਦਰ ਫੰਕਸ਼ਨ ਫਾਈਲ ਨੂੰ ਟੈਸਟ ਫਾਈਲ ਵਿੱਚ ਐਕਸੈਸ ਕਰਨ ਲਈ ਜਨਤਕ ਹੋਣ ਦੀ ਲੋੜ ਹੈ। ਇਹ ਸਿਸਟਮ ਨੂੰ ਇਹ ਯਕੀਨੀ ਬਣਾ ਕੇ ਸੁਰੱਖਿਅਤ ਅਤੇ ਕਾਰਜਕੁਸ਼ਲ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਕੋਡਬੇਸ ਦੇ ਹੋਰ ਹਿੱਸਿਆਂ ਵਿੱਚ ਸਿਰਫ਼ ਲੋੜੀਂਦੇ ਹਿੱਸੇ ਹੀ ਸਾਹਮਣੇ ਆਉਂਦੇ ਹਨ। ਆਪਣੇ ਮੋਡਿਊਲਾਂ ਅਤੇ ਟੈਸਟਾਂ ਨੂੰ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਢੰਗ ਨਾਲ ਸੰਗਠਿਤ ਕਰਕੇ, ਤੁਸੀਂ ਇਹ ਯਕੀਨੀ ਬਣਾ ਸਕਦੇ ਹੋ ਕਿ ਤੁਹਾਡੀ ਜੰਗਾਲ ਐਪਲੀਕੇਸ਼ਨ ਸਕੇਲੇਬਲ ਅਤੇ ਸਾਂਭਣਯੋਗ ਬਣੀ ਰਹੇ। ⚙️