การทดสอบหน่วยด้วย Python unittest Module

ไม่มีนักพัฒนาซอฟต์แวร์ที่ดีคนไหนที่ปรับใช้โค้ดโดยไม่มีการทดสอบอย่างละเอียดถี่ถ้วน การทดสอบหน่วยเป็นกระบวนการทดสอบแต่ละโมดูลของโปรแกรมขนาดใหญ่

บทความนี้จะกล่าวถึงวิธีการทดสอบหน่วยของรหัสโดยใช้โมดูล Python unittest ก่อนอื่นเรามาทำความเข้าใจว่าประเภทของการทดสอบคืออะไร

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

คุณจะเข้าใจว่าการทดสอบด้วยตนเองนั้นใช้เวลานานและทำได้ยาก ดังนั้นนักพัฒนาจึงเขียนโค้ดสำหรับการทดสอบ (การทดสอบอัตโนมัติ) มีการทดสอบหลายประเภทในการทดสอบอัตโนมัติ บางส่วน ได้แก่ การทดสอบหน่วย การทดสอบการบูรณาการ การทดสอบตั้งแต่ต้นจนจบ การทดสอบความเครียด ฯลฯ

มาดูขั้นตอนการทดสอบมาตรฐานกัน

• เขียนหรืออัปเดตรหัส
• เขียนหรืออัปเดตการทดสอบสำหรับกรณีต่างๆ สำหรับโค้ดของคุณ
• ทำการทดสอบ (ด้วยตนเองหรือใช้เครื่องทดสอบ)
• ดูผลการทดสอบ หากมีข้อผิดพลาด ให้แก้ไขและทำตามขั้นตอนซ้ำ

ในที่นี้ เราจะพูดถึงประเภทการทดสอบที่จำเป็นและพื้นฐานที่สุดที่เรียกว่าการทดสอบหน่วย โดยไม่ต้องกังวลใจอีกต่อไป เรามาดำดิ่งสู่บทช่วยสอนจริงกัน

การทดสอบหน่วยคืออะไร?

การทดสอบหน่วยเป็นเทคนิคในการทดสอบโค้ดอิสระกลุ่มเล็กๆ โค้ดบล็อกขนาดเล็กจะเป็นฟังก์ชันในกรณีส่วนใหญ่ คำว่าอิสระหมายความว่าไม่ขึ้นอยู่กับโค้ดส่วนอื่นๆ ในโครงการ

สมมติว่าเราต้องตรวจสอบว่าสตริงเท่ากับ “admintrick.com” หรือไม่ สำหรับสิ่งนั้น เราได้เขียนฟังก์ชันที่รับหนึ่งอาร์กิวเมนต์และส่งกลับไม่ว่าจะเท่ากับ “admintrick.com” หรือไม่

def is_equal_to_geekflare(string):
	return string == "admintrick.com"

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

ความสำคัญของการทดสอบหน่วย

โดยทั่วไปแล้ว รหัสบล็อกอิสระสามารถใช้ได้ทั่วทั้งโครงการ ดังนั้นจึงต้องเขียนและทดสอบอย่างดี การทดสอบหน่วยเป็นการทดสอบที่ใช้ในการทดสอบบล็อกรหัสอิสระประเภทเหล่านั้น จะเกิดอะไรขึ้นหากเราไม่ใช้การทดสอบหน่วยสำหรับโครงการของเรา

สมมติว่าเราไม่ได้ทดสอบโค้ดกลุ่มเล็กๆ ที่ใช้ในโปรเจ็กต์ การทดสอบอื่นๆ ทั้งหมด เช่น การทดสอบการรวมระบบ การทดสอบแบบ end-to-end เป็นต้น โดยใช้บล็อกเล็กๆ ของโค้ดอื่นๆ อาจล้มเหลว สิ่งนี้จะทำลายแอปพลิเคชัน นั่นเป็นเหตุผลที่หน่วยการสร้างพื้นฐานของรหัสต้องได้รับการทดสอบอย่างดี

ตอนนี้ เรารู้ถึงความสำคัญของการทดสอบหน่วยและการทดสอบหน่วยที่เป็นลายลักษณ์อักษรสำหรับบล็อกโค้ดอิสระทั้งหมด เนื่องจากเราทำการทดสอบหน่วยแล้ว การทดสอบอื่นๆ เช่น การทดสอบการรวมระบบ การทดสอบตั้งแต่ต้นทางถึงปลายทาง ฯลฯ จะไม่ล้มเหลวเนื่องจากการบล็อกรหัสที่แยกจากกัน

ในตอนต่อๆ ไป เราจะมาดูกันว่าโมดูล Python unittest คืออะไร และเราจะใช้โมดูล unittest ในการเขียนการทดสอบหน่วยใน Python ได้อย่างไร

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

Python unittest คืออะไร

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

เราต้องทำตามขั้นตอนด้านล่างเพื่อทดสอบรหัส Python โดยใช้โมดูล unittest

#1. เขียนรหัส

#2. นำเข้าโมดูล unittest

#3. สร้างไฟล์ที่ขึ้นต้นด้วยการทดสอบคีย์เวิร์ด ตัวอย่างเช่น test_prime.py การทดสอบคีย์เวิร์ดใช้เพื่อระบุไฟล์ทดสอบ

#4. สร้างคลาสที่ขยายคลาส unittest.TestCase

#5. เขียนวิธีการ (การทดสอบ) ภายในชั้นเรียน แต่ละวิธีประกอบด้วยกรณีทดสอบที่แตกต่างกันตามความต้องการของคุณ เราต้องตั้งชื่อเมธอดที่ขึ้นต้นด้วยคีย์เวิร์ดทดสอบ

#6. เรียกใช้การทดสอบ เราสามารถเรียกใช้การทดสอบได้หลายวิธี

• รันคำสั่ง python -m unittest test_filename.py
• เราเรียกใช้ไฟล์ทดสอบเหมือนไฟล์ Python ทั่วไป ด้วยคำสั่ง python test_filename.py เพื่อให้วิธีนี้ได้ผล เราต้องเรียกใช้เมธอดหลักของ unittest ในไฟล์ทดสอบ
• และสุดท้ายคือการใช้การค้นพบ เราสามารถรันการทดสอบอัตโนมัติได้โดยใช้คำสั่ง python -m unittest Discover โดยไม่ต้องเอ่ยชื่อไฟล์ของการทดสอบ จะพบการทดสอบโดยใช้หลักการตั้งชื่อที่เราปฏิบัติตาม ดังนั้น เราต้องตั้งชื่อไฟล์ทดสอบของเราด้วยคีย์เวิร์ด test ในการเริ่มต้น

โดยทั่วไป ในการทดสอบ เราจะเปรียบเทียบผลลัพธ์ของโค้ดกับผลลัพธ์ที่คาดไว้ ดังนั้นในการเปรียบเทียบผลลัพธ์ unittest จึงมีวิธีที่แตกต่างกัน คุณสามารถค้นหารายการของฟังก์ชันเปรียบเทียบได้ ที่นี่.

คุณสามารถเข้าใจได้โดยไม่ยาก พวกเขาตรงไปตรงมา

นั่นเป็นทฤษฎีมากมาย ตอนนี้เราต้องเข้าสู่การเข้ารหัส

หมายเหตุ: หากคุณมีข้อสงสัยใดๆ เกี่ยวกับโมดูล unittest คุณสามารถไปที่ เอกสาร และคลายความสงสัยของคุณ เราจะใช้โมดูล unittest โดยไม่ชักช้าอีกต่อไป

การทดสอบหน่วยใน Python โดยใช้ unittest

เราจะเขียนฟังก์ชันบางอย่างก่อน จากนั้นเราจะเน้นการเขียนการทดสอบ ขั้นแรก เปิดโฟลเดอร์ในโปรแกรมแก้ไขโค้ดที่คุณชื่นชอบ และสร้างไฟล์ชื่อ utils.py วางรหัสต่อไปนี้ในไฟล์

import math


def is_prime(n):
    if n < 0:
        return 'Negative numbers are not allowed'

    if n <= 1:
        return False

    if n == 2:
        return True

    if n % 2 == 0:
        return False

    for i in range(2, int(math.sqrt(n)) + 1):
        if n % i == 0:
            return False
    return True


def cubic(a):
    return a * a * a


def say_hello(name):
    return "Hello, " + name

เรามีสามฟังก์ชันที่แตกต่างกันในไฟล์ utils.py ตอนนี้เราต้องทดสอบแต่ละฟังก์ชันด้วยกรณีทดสอบที่แตกต่างกัน มาเขียนการทดสอบสำหรับฟังก์ชันแรก is_prime กัน

#1. สร้างไฟล์ชื่อ test_utils.py ในโฟลเดอร์ตัวอย่างเป็น utils.py

#2. นำเข้าโมดูล utils และ unittest

#3. สร้างคลาสด้วยชื่อ TestUtils ขยายคลาส unittest.TestCase ชื่อของชั้นเรียนสามารถเป็นอะไรก็ได้ พยายามตั้งชื่อชั้นเรียนให้มีความหมาย

#4. ภายในคลาส ให้เขียนเมธอดชื่อ test_is_prime ซึ่งยอมรับตนเองเป็นอาร์กิวเมนต์

#5. เขียนกรณีทดสอบที่แตกต่างกันพร้อมอาร์กิวเมนต์ของ is_prime และเปรียบเทียบผลลัพธ์กับผลลัพธ์ที่คาดไว้

#6. ตัวอย่างกรณีทดสอบ self.assertFalse(utils.is_prime(1))

#7. เราคาดว่าผลลัพธ์ของ is_prime(1) จะเป็นเท็จในกรณีข้างต้น

#8. คล้ายกับกรณีข้างต้น เราจะทดสอบกรณีต่างๆ ตามฟังก์ชันที่เรากำลังทดสอบ

มาดูการทดสอบกัน

import unittest

import utils


class TestUtils(unittest.TestCase):
    def test_is_prime(self):
        self.assertFalse(utils.is_prime(4))
        self.assertTrue(utils.is_prime(2))
        self.assertTrue(utils.is_prime(3))
        self.assertFalse(utils.is_prime(8))
        self.assertFalse(utils.is_prime(10))
        self.assertTrue(utils.is_prime(7))
        self.assertEqual(utils.is_prime(-3),
                         "Negative numbers are not allowed")


if __name__ == '__main__':
    unittest.main()

เรากำลังเรียกใช้เมธอดหลัก unittest โมดูลเพื่อรันการทดสอบโดยใช้คำสั่ง python filename.py ตอนนี้เรียกใช้การทดสอบ

คุณจะเห็นผลลัพธ์ที่คล้ายกับผลลัพธ์ด้านล่าง

$ python test_utils.py 
.
----------------------------------------------------------------------
Ran 1 test in 0.001s

OK

ตอนนี้ลองเขียนกรณีทดสอบสำหรับฟังก์ชันอื่นด้วย นึกถึงกรณีต่างๆ สำหรับฟังก์ชันและเขียนการทดสอบสำหรับกรณีเหล่านั้น ลองดูแบบทดสอบต่อไปนี้ที่เพิ่มเข้ามาในชั้นเรียนข้างต้น

...


class TestUtils(unittest.TestCase):
    def test_is_prime(self):
        ...

    def test_cubic(self):
        self.assertEqual(utils.cubic(2), 8)
        self.assertEqual(utils.cubic(-2), -8)
        self.assertNotEqual(utils.cubic(2), 4)
        self.assertNotEqual(utils.cubic(-3), 27)

    def test_say_hello(self):
        self.assertEqual(utils.say_hello("admintrick.com"), "Hello, admintrick.com")
        self.assertEqual(utils.say_hello("Chandan"), "Hello, Chandan")
        self.assertNotEqual(utils.say_hello("Chandan"), "Hi, Chandan")
        self.assertNotEqual(utils.say_hello("Hafeez"), "Hi, Hafeez")


...

เราใช้ฟังก์ชันเปรียบเทียบบางส่วนจากโมดูล unittest เท่านั้น คุณสามารถค้นหารายการทั้งหมด ที่นี่.

เราได้เรียนรู้วิธีการเขียนการทดสอบหน่วยโดยใช้โมดูลการทดสอบหน่วย ตอนนี้ ถึงเวลาดูวิธีต่างๆ ในการทำการทดสอบ

วิธีเรียกใช้การทดสอบโดยใช้ unittest

เราได้เห็นวิธีการเรียกใช้กรณีทดสอบในส่วนด้านบนแล้ว มาดูอีกสองวิธีในการรันการทดสอบโดยใช้โมดูล unittest

#1. โดยใช้ชื่อไฟล์และโมดูล unittest

ในวิธีนี้ เราจะใช้โมดูล unittest และชื่อไฟล์เพื่อเรียกใช้การทดสอบ คำสั่งสำหรับเรียกใช้การทดสอบคือ python -m unittest filename.py ในกรณีของเรา คำสั่งสำหรับรันการทดสอบคือ python -m unittest test_utils.py

#2. โดยใช้วิธีค้นพบ

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

คำสั่งสำหรับรันการทดสอบโดยใช้วิธีการ Discover คือ python -m unittest Discover คำสั่งจะตรวจจับไฟล์ทั้งหมดที่มีชื่อขึ้นต้นด้วยการทดสอบและดำเนินการ

สรุป 👩‍💻

การทดสอบหน่วยเป็นการทดสอบพื้นฐานในโลกของการเขียนโปรแกรม มีการทดสอบอื่น ๆ อีกมากมายในโลกแห่งความเป็นจริง พยายามเรียนรู้พวกเขาทีละคน ฉันหวังว่าบทช่วยสอนนี้จะช่วยให้คุณเขียนการทดสอบพื้นฐานใน Python โดยใช้โมดูล unittest มีไลบรารีของบุคคลที่สามเช่น pytest, Robot Framework, nose, nose2, slash เป็นต้น คุณสามารถสำรวจได้ตามข้อกำหนดของโปรเจกต์ของคุณ

มีความสุขในการทดสอบ😎

คุณอาจสนใจคำถามและคำตอบสัมภาษณ์ Python