Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

การจัดระเบียบเทสต์

ดังที่ได้กล่าวไว้ในตอนต้นบท การทดสอบ (testing) เป็นศาสตร์ที่มีความละเอียดซับซ้อน และแต่ละคนอาจใช้คำศัพท์ตลอดจนวิธีการจัดระเบียบที่แตกต่างกันไป ในชุมชน Rust เราจะแบ่งประเภทของเทสต์ออกเป็น 2 หมวดหมู่หลัก ได้แก่: ยูนิตเทสต์ (unit tests) และอินทิเกรชันเทสต์ (integration tests) โดย ยูนิตเทสต์ จะมีขอบเขตขนาดเล็กและมุ่งเน้นความเฉพาะเจาะจง ทำหน้าที่ทดสอบแต่ละมอดูล (module) แบบแยกเดี่ยวทีละส่วน และสามารถเข้าถึงเพื่อทดสอบอินเทอร์เฟซที่เป็นส่วนตัว (private interface) ได้ ส่วน อินทิเกรชันเทสต์ จะอยู่ภายนอกไลบรารีของคุณโดยสมบูรณ์ และเรียกใช้งานโค้ดของคุณในลักษณะเดียวกับที่โค้ดภายนอกอื่นๆ ใช้งาน โดยจะเข้าถึงได้เฉพาะอินเทอร์เฟซที่เป็นสาธารณะ (public interface) เท่านั้น และเทสต์แต่ละตัวอาจครอบคลุมการทำงานร่วมกันของหลายๆ มอดูลพร้อมกัน

การเขียนชุดทดสอบทั้งสองประเภทนี้มีความสำคัญอย่างยิ่ง เพื่อให้มั่นใจได้ว่าส่วนประกอบต่างๆ ในไลบรารีของคุณสามารถทำงานได้ตรงตามที่คาดหวัง ทั้งในระดับแยกส่วนเดี่ยวๆ และในระดับการทำงานประสานกัน

การทดสอบระดับยูนิต

จุดประสงค์ของยูนิตเทสต์คือ การทดสอบโค้ดแต่ละหน่วยย่อยโดยแยกขาดจากโค้ดส่วนอื่นๆ เพื่อให้สามารถระบุตำแหน่งได้อย่างรวดเร็วว่าโค้ดส่วนใดทำงานถูกต้อง และส่วนใดไม่ทำงานตามที่คาดหวัง เราจะวางยูนิตเทสต์ไว้ในไดเรกทอรี src ภายในไฟล์เดียวกันกับโค้ดที่ต้องการทดสอบ โดยธรรมเนียมปฏิบัติคือ ให้สร้างมอดูลชื่อ tests ขึ้นมาในแต่ละไฟล์เพื่อบรรจุฟังก์ชันเทสต์ และกำกับมอดูลนั้นไว้ด้วย cfg(test)

มอดูล tests และ #[cfg(test)]

แอตทริบิวต์กำกับ #[cfg(test)] บนมอดูล tests จะสั่งให้ Rust คอมไพล์และรันโค้ดทดสอบเฉพาะเมื่อเราสั่งรันคำสั่ง cargo test เท่านั้น ไม่ใช่ตอนที่เราสั่งรัน cargo build ซึ่งช่วยประหยัดเวลาในการคอมไพล์เมื่อเราต้องการเพียงแค่บิลด์ไลบรารีไปใช้งาน และช่วยลดขนาดของไฟล์ไบนารีผลลัพธ์ลงเนื่องจากไม่มีโค้ดเทสต์แฝงอยู่ คุณจะเห็นว่าเนื่องจากอินทิเกรชันเทสต์จะถูกจัดเก็บไว้ในอีกไดเรกทอรีหนึ่งต่างหาก จึงไม่จำเป็นต้องใส่ #[cfg(test)] กำกับไว้ แต่สำหรับยูนิตเทสต์ที่เขียนอยู่ภายในไฟล์เดียวกับโค้ดหลัก เราจึงต้องใช้ #[cfg(test)] เพื่อระบุไม่ให้นำโค้ดเหล่านี้ไปรวมไว้ในผลลัพธ์การบิลด์ทั่วไป

ย้อนกลับไปตอนที่เราสร้างโปรเจกต์ adder ใหม่ในหัวข้อแรกของบทนี้ Cargo ได้สร้างโค้ดเริ่มต้นมาให้เราดังนี้:

ชื่อไฟล์: src/lib.rs

pub fn add(left: u64, right: u64) -> u64 {
    left + right
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn it_works() {
        let result = add(2, 2);
        assert_eq!(result, 4);
    }
}

ในมอดูล tests ที่สร้างขึ้นอัตโนมัตินี้ แอตทริบิวต์ cfg ย่อมาจากคำว่า configuration (การกำหนดค่า) ซึ่งคอยบอก Rust ว่ารายการโค้ดที่ตามมาควรถูกนำมารวมในการคอมไพล์เฉพาะเมื่อมีตัวเลือกการกำหนดค่าที่ระบุไว้เท่านั้น ในกรณีนี้ ตัวเลือกการกำหนดค่าคือ test ซึ่ง Rust จัดเตรียมไว้สำหรับการคอมไพล์และรันเทสต์โดยเฉพาะ การใช้แอตทริบิวต์ cfg ทำให้ Cargo จะคอมไพล์โค้ดเทสต์ของเราก็ต่อเมื่อเราตั้งใจสั่งรันเทสต์ด้วย cargo test เท่านั้น ซึ่งครอบคลุมไปถึงฟังก์ชันตัวช่วย (helper functions) ใดๆ ที่อาจเขียนไว้ภายในมอดูลนี้ นอกเหนือจากฟังก์ชันที่กำกับด้วย #[test]

การทดสอบฟังก์ชันแบบส่วนตัว

ในแวดวงการทดสอบซอฟต์แวร์ยังคงมีการถกเถียงกันอยู่เสมอว่า เราควรทดสอบฟังก์ชันแบบส่วนตัว (private functions) โดยตรงหรือไม่ ซึ่งในภาษาโปรแกรมอื่นๆ หลายภาษาอาจทำให้การทดสอบฟังก์ชันส่วนตัวเป็นเรื่องยากหรือทำไม่ได้เลย แต่ไม่ว่าคุณจะยึดถือแนวคิดการทดสอบแบบใด กฎเรื่องการเปิดเผย (privacy rules) ของ Rust อนุญาตให้คุณสามารถทดสอบฟังก์ชันแบบส่วนตัวได้อย่างเต็มที่ ลองพิจารณาโค้ดในลิสติ้ง 11-12 ซึ่งมีฟังก์ชันแบบส่วนตัวชื่อ internal_adder

pub fn add_two(a: u64) -> u64 {
    internal_adder(a, 2)
}

fn internal_adder(left: u64, right: u64) -> u64 {
    left + right
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn internal() {
        let result = internal_adder(2, 2);
        assert_eq!(result, 4);
    }
}

โปรดสังเกตว่าฟังก์ชัน internal_adder ไม่ได้ถูกประกาศด้วยคำว่า pub เลย เทสต์ก็เป็นเพียงโค้ด Rust ธรรมดา และมอดูล tests ก็เป็นเพียงมอดูลหนึ่งเท่านั้น ตามที่เราได้อธิบายไว้ในหัวข้อ“พาธสำหรับอ้างถึงรายการในแผนผังมอดูล” รายการต่างๆ ที่อยู่ในมอดูลลูกสามารถเรียกใช้งานรายการที่อยู่ในมอดูลบรรพบุรุษของมันได้เสมอ ในเทสต์นี้ เรานำรายการทั้งหมดของมอดูลแม่เข้ามาสู่สโคปด้วย use super::* ฟังก์ชันเทสต์จึงสามารถเรียกใช้งาน internal_adder ได้โดยตรง และหากคุณมองว่าไม่จำเป็นต้องทดสอบฟังก์ชันแบบส่วนตัว Rust ก็ไม่ได้มีข้อบังคับใดๆ ให้คุณต้องทำเช่นนั้น

การทดสอบแบบอินทิเกรชัน

ในภาษา Rust อินทิเกรชันเทสต์ (integration tests) จะอยู่ภายนอกไลบรารีของคุณโดยสมบูรณ์ พวกมันจะเรียกใช้งานไลบรารีในลักษณะเดียวกับที่โค้ดภายนอกอื่นๆ ใช้งาน ซึ่งหมายความว่ามันจะสามารถเรียกใช้ได้เฉพาะฟังก์ชันที่เป็นส่วนหนึ่งของ API สาธารณะ (public API) ของไลบรารีเท่านั้น จุดประสงค์หลักของอินทิเกรชันเทสต์คือการตรวจสอบว่าส่วนประกอบต่างๆ ของไลบรารีสามารถทำงานร่วมกันได้อย่างถูกต้องหรือไม่ เพราะหน่วยของโค้ดที่ทำงานได้ดีเมื่ออยู่เดี่ยวๆ อาจเกิดปัญหาขึ้นได้เมื่อนำมาเชื่อมต่อเข้าด้วยกัน ดังนั้นความครอบคลุมของการทดสอบในระดับบูรณาการจึงมีความสำคัญอย่างยิ่ง ในการสร้างอินทิเกรชันเทสต์ ขั้นตอนแรกที่คุณต้องมีคือไดเรกทอรี tests

ไดเรกทอรี tests

เราจะสร้างไดเรกทอรีชื่อ tests ไว้ที่ระดับบนสุดของไดเรกทอรีโปรเจกต์ ซึ่งจะอยู่คู่กับไดเรกทอรี src โดย Cargo จะทราบโดยอัตโนมัติว่าจะต้องค้นหาไฟล์อินทิเกรชันเทสต์ในไดเรกทอรีนี้ จากนั้นเราสามารถสร้างไฟล์เทสต์ได้มากเท่าที่ต้องการ และ Cargo จะคอมไพล์แต่ละไฟล์ให้เป็นเครต (crate) แยกต่างหากออกจากกัน

มาลองสร้างอินทิเกรชันเทสต์กัน โดยคงโค้ดในลิสติ้ง 11-12 ไว้ในไฟล์ src/lib.rs ให้สร้างไดเรกทอรี tests ขึ้นมา แล้วสร้างไฟล์ใหม่ชื่อ tests/integration_test.rs โครงสร้างไดเรกทอรีของคุณควรมีหน้าตาดังนี้:

adder
├── Cargo.lock
├── Cargo.toml
├── src
│   └── lib.rs
└── tests
    └── integration_test.rs

จากนั้นให้ใส่โค้ดในลิสติ้ง 11-13 ลงในไฟล์ tests/integration_test.rs

use adder::add_two;

#[test]
fn it_adds_two() {
    let result = add_two(2);
    assert_eq!(result, 4);
}

เนื่องจากแต่ละไฟล์ในไดเรกทอรี tests ถือเป็นเครตแยกต่างหากกัน เราจึงจำเป็นต้องอิมพอร์ตไลบรารีของเราเข้ามายังสโคปของแต่ละเครตเทสต์ ด้วยเหตุนี้ เราจึงต้องเพิ่ม use adder::add_two; ไว้ที่ตอนต้นของโค้ด ซึ่งเป็นสิ่งที่เราไม่ต้องทำในยูนิตเทสต์

เราไม่จำเป็นต้องใส่แอตทริบิวต์ #[cfg(test)] กำกับไว้บนโค้ดใดๆ ใน tests/integration_test.rs เลย เพราะ Cargo มีกลไกพิเศษสำหรับไดเรกทอรี tests โดยจะคอมไพล์ไฟล์ในไดเรกทอรีนี้เฉพาะเมื่อเราสั่งรัน cargo test เท่านั้น ลองรัน cargo test ดูตอนนี้:

$ cargo test
   Compiling adder v0.1.0 (file:///projects/adder)
    Finished `test` profile [unoptimized + debuginfo] target(s) in 1.31s
     Running unittests src/lib.rs (target/debug/deps/adder-1082c4b063a8fbe6)

running 1 test
test tests::internal ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

     Running tests/integration_test.rs (target/debug/deps/integration_test-1082c4b063a8fbe6)

running 1 test
test it_adds_two ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

   Doc-tests adder

running 0 tests

test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

เอาต์พุตที่แสดงผลออกมาจะแบ่งเป็น 3 ส่วนหลัก ได้แก่ ยูนิตเทสต์, อินทิเกรชันเทสต์, และด็อกเทสต์ (doc test) โปรดสังเกตว่าหากมีเทสต์ในส่วนใดส่วนหนึ่งล้มเหลว ส่วนที่เหลือถัดไปจะไม่ถูกรัน ตัวอย่างเช่น หากมียูนิตเทสต์ล้มเหลว จะไม่มีเอาต์พุตของอินทิเกรชันเทสต์และด็อกเทสต์แสดงออกมาเลย เนื่องจากเทสต์เหล่านั้นจะถูกสั่งรันก็ต่อเมื่อยูนิตเทสต์ทั้งหมดผ่านอย่างสมบูรณ์แล้วเท่านั้น

ส่วนแรกสำหรับยูนิตเทสต์จะมีลักษณะเช่นเดียวกับที่เราเคยเห็น: แสดงหนึ่งบรรทัดต่อหนึ่งฟังก์ชันยูนิตเทสต์ (มีตัวหนึ่งชื่อ internal ที่เราเพิ่มไว้ในลิสติ้ง 11-12) ตามด้วยบรรทัดสรุปผลลัพธ์ของยูนิตเทสต์

ส่วนของอินทิเกรชันเทสต์จะเริ่มต้นด้วยบรรทัด Running tests/integration_test.rs จากนั้นจะมีบรรทัดแสดงผลของแต่ละฟังก์ชันเทสต์ในไฟล์อินทิเกรชันเทสต์นั้น และตามด้วยบรรทัดสรุปผลลัพธ์ของอินทิเกรชันเทสต์ ก่อนที่ส่วน Doc-tests adder จะเริ่มต้นขึ้น

ไฟล์อินทิเกรชันเทสต์แต่ละไฟล์จะมีส่วนแสดงผลแยกเป็นของตนเอง ดังนั้นหากเราเพิ่มไฟล์เข้าไปในไดเรกทอรี tests อีก ก็จะมีส่วนแสดงผลของอินทิเกรชันเทสต์เพิ่มขึ้นตามไปด้วย

เรายังคงสามารถสั่งรันเฉพาะฟังก์ชันอินทิเกรชันเทสต์ที่เจาะจงได้ โดยระบุชื่อของฟังก์ชันเทสต์เป็นอาร์กิวเมนต์ให้กับ cargo test และหากต้องการรันเทสต์ทั้งหมดที่อยู่ในไฟล์อินทิเกรชันเทสต์ไฟล์ใดไฟล์หนึ่งโดยเฉพาะ ให้ใช้อาร์กิวเมนต์ --test ของ cargo test ตามด้วยชื่อของไฟล์นั้น:

$ cargo test --test integration_test
   Compiling adder v0.1.0 (file:///projects/adder)
    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.64s
     Running tests/integration_test.rs (target/debug/deps/integration_test-82e7799c1bc62298)

running 1 test
test it_adds_two ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

คำสั่งนี้จะรันเฉพาะเทสต์ที่อยู่ในไฟล์ tests/integration_test.rs เท่านั้น

มอดูลย่อยในการทดสอบแบบอินทิเกรชัน

เมื่อคุณเริ่มมีอินทิเกรชันเทสต์มากขึ้น คุณอาจต้องการสร้างไฟล์เพิ่มเติมในไดเรกทอรี tests เพื่อช่วยจัดหมวดหมู่ให้เป็นระเบียบ เช่น การจัดกลุ่มฟังก์ชันเทสต์ตามฟังก์ชันการทำงานที่ต้องการทดสอบ ดังที่ได้กล่าวไปแล้วว่า แต่ละไฟล์ในไดเรกทอรี tests จะถูกคอมไพล์ให้เป็นเครตแยกจากกัน ซึ่งมีประโยชน์อย่างยิ่งในการจำลองสโคปแบบแยกส่วนให้ใกล้เคียงกับวิธีที่ผู้ใช้งานจริงจะเรียกใช้เครตของคุณ อย่างไรก็ตาม สิ่งนี้ส่งผลให้ไฟล์ในไดเรกทอรี tests มีพฤติกรรมไม่เหมือนกับไฟล์ในไดเรกทอรี src ตามที่คุณเคยเรียนรู้ในบทที่ 7 เกี่ยวกับการแยกโค้ดออกเป็นมอดูลและไฟล์

ความแตกต่างของพฤติกรรมนี้จะเห็นได้ชัดเจนที่สุดเมื่อคุณมีชุดฟังก์ชันตัวช่วย (helper functions) ที่ต้องการใช้ร่วมกันในหลายๆ ไฟล์อินทิเกรชันเทสต์ และคุณพยายามทำตามขั้นตอนในหัวข้อ“แยกมอดูลออกเป็นไฟล์ต่างๆ” ของบทที่ 7 เพื่อแยกโค้ดเหล่านั้นออกมาเป็นมอดูลส่วนกลาง ตัวอย่างเช่น หากเราสร้างไฟล์ tests/common.rs แล้วใส่ฟังก์ชันชื่อ setup ไว้ข้างใน เพื่อให้สามารถเรียกใช้ได้จากหลายฟังก์ชันเทสต์ในหลายไฟล์:

ชื่อไฟล์: tests/common.rs

pub fn setup() {
    // setup code specific to your library's tests would go here
}

เมื่อเราสั่งรันเทสต์อีกครั้ง เราจะเห็นส่วนใหม่ปรากฏขึ้นมาในเอาต์พุตสำหรับไฟล์ common.rs ทั้งๆ ที่ไฟล์นี้ไม่มีฟังก์ชันเทสต์อยู่เลย และเราก็ยังไม่ได้เรียกฟังก์ชัน setup จากที่ไหนด้วยซ้ำ:

$ cargo test
   Compiling adder v0.1.0 (file:///projects/adder)
    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.89s
     Running unittests src/lib.rs (target/debug/deps/adder-92948b65e88960b4)

running 1 test
test tests::internal ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

     Running tests/common.rs (target/debug/deps/common-92948b65e88960b4)

running 0 tests

test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

     Running tests/integration_test.rs (target/debug/deps/integration_test-92948b65e88960b4)

running 1 test
test it_adds_two ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

   Doc-tests adder

running 0 tests

test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

การที่ common โผล่ขึ้นมาในผลการทดสอบพร้อมข้อความ running 0 tests ไม่ใช่สิ่งที่เราต้องการ เพราะเราเพียงแค่ต้องการแชร์โค้ดตัวช่วยร่วมกับไฟล์อินทิเกรชันเทสต์อื่นๆ เท่านั้น เพื่อหลีกเลี่ยงไม่ให้ common ปรากฏในเอาต์พุตการทดสอบ แทนที่เราจะสร้างไฟล์ tests/common.rs ให้เราสร้างเป็น tests/common/mod.rs แทน ซึ่งทำให้โครงสร้างไดเรกทอรีมีหน้าตาดังนี้:

├── Cargo.lock
├── Cargo.toml
├── src
│   └── lib.rs
└── tests
    ├── common
    │   └── mod.rs
    └── integration_test.rs

นี่คือธรรมเนียมการตั้งชื่อรูปแบบดั้งเดิมที่ Rust เข้าใจได้เช่นกัน ตามที่เราเคยกล่าวถึงใน“พาธไฟล์ทางเลือก” ในบทที่ 7 การตั้งชื่อไฟล์ในรูปแบบนี้จะบอกให้ Rust ทราบว่าอย่าปฏิบัติต่อมอดูล common ในฐานะไฟล์อินทิเกรชันเทสต์ และเมื่อเราย้ายโค้ดฟังก์ชัน setup ไปไว้ใน tests/common/mod.rs พร้อมทั้งลบไฟล์ tests/common.rs ทิ้งไป ส่วนของ common ในเอาต์พุตเทสต์ก็จะไม่ปรากฏขึ้นอีก ไฟล์ทั้งหมดที่อยู่ในไดเรกทอรีย่อยของ tests จะไม่ถูกคอมไพล์เป็นเครตแยกเดี่ยว และจะไม่มีส่วนแสดงผลในเอาต์พุตการทดสอบ

หลังจากที่เราสร้างไฟล์ tests/common/mod.rs เรียบร้อยแล้ว เราจะสามารถเรียกใช้งานมันในฐานะมอดูลจากไฟล์อินทิเกรชันเทสต์ใดๆ ก็ได้ ต่อไปนี้เป็นตัวอย่างการเรียกฟังก์ชัน setup จากเทสต์ it_adds_two ในไฟล์ tests/integration_test.rs:

ชื่อไฟล์: tests/integration_test.rs

use adder::add_two;

mod common;

#[test]
fn it_adds_two() {
    common::setup();

    let result = add_two(2);
    assert_eq!(result, 4);
}

โปรดสังเกตว่าการประกาศ mod common; นั้นเป็นรูปแบบเดียวกับที่เราเคยแสดงไว้ในลิสติ้ง 7-21 จากนั้นภายในฟังก์ชันเทสต์ เราจึงสามารถเรียกใช้คำสั่ง common::setup() ได้อย่างราบรื่น

การทดสอบแบบอินทิเกรชันสำหรับเครตไบนารี

หากโปรเจกต์ของเราเป็นเครตไบนารี (binary crate) ที่มีเพียงไฟล์ src/main.rs และไม่มีไฟล์ src/lib.rs เราจะไม่สามารถสร้างอินทิเกรชันเทสต์ในไดเรกทอรี tests เพื่อนำฟังก์ชันที่นิยามในไฟล์ src/main.rs เข้ามาสู่สโคปด้วยคำสั่ง use ได้ เพราะมีเพียงเครตไลบรารี (library crate) เท่านั้นที่เปิดเผยฟังก์ชันให้เครตอื่นๆ เรียกใช้งานได้ ส่วนเครตไบนารีถูกออกแบบมาเพื่อให้รันการทำงานด้วยตัวมันเองโดยเฉพาะ

นี่จึงเป็นหนึ่งในเหตุผลสำคัญที่โปรเจกต์ Rust ที่เป็นไบนารีมักจะมีไฟล์ src/main.rs ที่เรียบง่ายและทำหน้าที่เพียงแค่เรียกใช้ตรรกะการทำงานหลักที่อยู่ในไฟล์ src/lib.rs การใช้โครงสร้างเช่นนี้ทำให้อินทิเกรชันเทสต์_สามารถ_ทดสอบเครตไลบรารีผ่านคำสั่ง use เพื่อเข้าถึงฟังก์ชันการทำงานที่สำคัญได้ และหากฟังก์ชันการทำงานหลักเหล่านั้นทำงานได้ถูกต้อง โค้ดเพียงเล็กน้อยที่อยู่ใน src/main.rs ก็จะทำงานได้อย่างถูกต้องตามไปด้วย โดยไม่จำเป็นต้องเขียนชุดทดสอบให้กับโค้ดส่วนเล็กๆ นั้นแยกต่างหาก

สรุป

ฟีเจอร์การทดสอบของ Rust มอบแนวทางในการกำหนดและตรวจสอบพฤติกรรมการทำงานของโค้ด เพื่อให้มั่นใจได้ว่าโปรแกรมจะยังคงทำงานได้ถูกต้องตรงตามความคาดหวังเสมอ แม้ในยามที่คุณต้องแก้ไขปรับปรุงโค้ดก็ตาม ยูนิตเทสต์ช่วยให้เราทดสอบชิ้นส่วนต่างๆ ของไลบรารีแยกจากกัน และสามารถทดสอบลงลึกไปถึงรายละเอียดการทำงานแบบส่วนตัวได้ ส่วนอินทิเกรชันเทสต์จะช่วยตรวจสอบว่าส่วนต่างๆ ของไลบรารีสามารถทำงานร่วมกันได้อย่างสมบูรณ์ โดยเรียกใช้ผ่าน API สาธารณะของไลบรารีในลักษณะเดียวกับที่โค้ดภายนอกนำไปใช้งาน แม้ว่าระบบชนิดข้อมูลและกฎความเป็นเจ้าของของ Rust จะช่วยป้องกันข้อผิดพลาดได้มากมายหลายประเภท แต่การเขียนชุดทดสอบก็ยังคงเป็นหัวใจสำคัญในการลดทอนข้อผิดพลาดเชิงตรรกะ (logic bugs) เกี่ยวกับพฤติกรรมที่โค้ดควรจะเป็น

มานำความรู้ทั้งหมดที่คุณได้เรียนรู้ในบทนี้และบทก่อนๆ มาผสมผสานเพื่อร่วมกันลงมือพัฒนาโปรเจกต์จริงกันเถอะ!