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

ในความคิดของฉัน เราต้องเลือกกรอบการทดสอบที่เหมาะสมก่อน ฉันพบผลลัพธ์ที่ยอดเยี่ยมด้วย Mocha — มันยืดหยุ่นพอที่จะช่วยให้เราใช้ประโยชน์จากไลบรารีอื่นๆ ด้วย แม้จะมีความเรียบง่าย แต่ก็สนับสนุนการสร้างสถาปัตยกรรมการทดสอบที่น่านับถือซึ่งเหมาะกับโครงการ TypeScript เป็นอย่างดี - ทั้งหมดโดยใช้ตะขอ

มอคค่าตะขอ

Mocha มี hooks 4 ประเภท:
* beforeEach(ก่อนการทดสอบทุกรายการในบล็อกใดบล็อกหนึ่งจะถูกดำเนินการ),
* beforeAll(ก่อนการทดสอบทั้งหมดในบล็อกหนึ่งๆ จะถูกดำเนินการ),
* afterEach(หลังจากการทดสอบทุกรายการในบล็อกหนึ่งๆ จะถูกดำเนินการ),
* afterAll( หลังจากการทดสอบทั้งหมดในบล็อกหนึ่งๆ ถูกดำเนินการ)

ฉันใช้คำว่า "เฉพาะ" โดยตั้งใจ เนื่องจาก Mocha ช่วยให้เราสามารถตั้งค่า hooks ในระดับที่มีความหมายได้ อย่างที่คุณอาจทราบแล้ว สถาปัตยกรรมการทดสอบค่อนข้างเป็นโครงสร้างระดับโลก และเราตั้งใจที่จะตั้งค่า hooks ในระดับโลก เพื่อให้บรรลุเป้าหมายนั้น เราต้องเจาะลึกเข้าไปในการกำหนดค่าการทดสอบ

Root Mocha Hooks

Root Mocha Hooks ใช้กับการทดสอบทั้งหมดในการตั้งค่าการทดสอบทั้งหมด วิธีที่คุณใช้สิ่งเหล่านี้เป็นการตัดสินใจของคุณอย่างหลีกเลี่ยงไม่ได้ อย่างไรก็ตาม ฉันอยากจะเสนอรายการความคิดของฉันให้คุณ ฉันมักจะพึ่งพาการกำหนดค่าที่เหมาะสมของ hooks เหล่านี้อย่างมากในการทดสอบของฉัน ซึ่งช่วยลดงานจำนวนมากสำหรับผู้ที่เขียนการทดสอบ

บริบทมอคค่า

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

เนื่องจากMocha.Contextเป็นคลาส (ไม่ใช่อินเทอร์เฟซที่ขยายได้) เราควรกำหนดสองประเภท — InjectableContextสำหรับคุณสมบัติที่เราจัดการและTestContextสำหรับคุณสมบัติทั้งหมดที่สิ้นสุดเป็นส่วนหนึ่งของบริบท TestContextจะเป็นแบบที่ใช้ในการทดสอบ ตัวอย่างง่ายๆด้านล่างควรล้างแนวคิดนี้:

หากคุณสงสัยว่าเหตุใดฉันจึงใช้Readonlyประเภทในตัวอย่างด้านบน คุณได้รับเชิญให้อ่านบทความของฉันเกี่ยวกับการไม่เปลี่ยนรูปแบบใน TypeScript ซึ่งเผยแพร่ในสิ่งพิมพ์ Level Up Coding:

ก่อนเบ็ดทั้งหมด

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

โดยองค์ประกอบของระบบ ฉันเข้าใจสิ่งต่อไปนี้ (รายการไม่สมบูรณ์):
* ฐานข้อมูลจำลอง
* เซิร์ฟเวอร์จำลอง
* ระบบข้อความจำลอง
* บริการที่ใช้ร่วมกัน
* ตัวควบคุม
* ฟังก์ชันตัวช่วยที่มีประโยชน์

หากคุณมีการทดสอบจำนวนมากและใช้การทำให้เป็นคู่ขนานกัน โปรดทราบว่า Mocha จะดำเนินการเบ็ด Before All สำหรับแต่ละไฟล์ทดสอบ

ก่อนตะขอแต่ละอัน

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

หลังจากตะขอทั้งหมด

ทุกสิ่งที่เราเริ่มต้นเป็นส่วนหนึ่งของเบ็ด Before All เราต้องรื้อลงเป็นส่วนหนึ่งของเบ็ด After Each เพื่อให้ Mocha เสร็จสิ้นและให้ผลลัพธ์ใด ๆ ทรัพยากรที่ห้อยอยู่ทั้งหมดจะต้องได้รับการปลดปล่อย ในกรณีของการทดสอบแบบขนาน Mocha จะดำเนินการ hook นี้สำหรับไฟล์ทดสอบแต่ละไฟล์

หลังจากแต่ละตะขอ

ดังที่ได้กล่าวไว้ก่อนหน้านี้ ตะขอ After Each ทำงานควบคู่กับตะขอ Before Each ซึ่งหมายความว่าหากมีการใส่คำสั่งรีเซ็ตบางอย่างในตะขอเหล่านี้ มีแนวโน้มว่าเราไม่จำเป็นต้องใส่ในตะขออื่น ตัวอย่างเช่น ถ้าเรารีเซ็ตตัวนับเป็นศูนย์ในเบ็ด Before Each เราไม่ต้องทำในเบ็ด After Each ที่สอดคล้องกัน

ติดตั้ง

เนื่องจากฉันได้อธิบายทฤษฎีนี้แล้ว เราควรลองตั้งค่า Root Mocha Hooks ในโครงการ TypeScript หากการกำหนดค่า Mocha ถูกเก็บไว้ใน.mocharc.ymlไฟล์ที่อยู่ในไดเร็กทอรีแอปพลิเคชันหลัก เราจำเป็นต้องพิมพ์ดังต่อไปนี้:

สิ่งนี้บอก Mocha ว่าเราต้องการลงทะเบียนตัวโหลด TypeScript (โดยใช้ไลบรารี่ts-node) และเราต้องการเฟรมเวิร์กการทดสอบเพื่อรันtest/rootMochaHooks.tsไฟล์ ไฟล์นี้จะมี Rook Mocha Hooks ตามชื่อของมัน

โครงสร้างพื้นฐานที่สุดของไฟล์นั้นมีดังนี้:

ไฟล์จำเป็นต้องส่งออกฟังก์ชันที่เรียกmochaHooksว่าส่งคืนMocha.RootHookObjectหรือPromiseประเภทนั้น ฟังก์ชันทั้งหมดที่กำหนดเป็นส่วนหนึ่งของค่าส่งคืนสามารถเป็นแบบอะซิงโครนัสได้เช่นกัน ตาดีสามารถจับว่าbeforeAllฟังก์ชั่นที่ยอมรับthisของMocha.Contextประเภท แต่ฟังก์ชั่นอื่น ๆ ทั้งหมดที่มีอยู่แล้วได้รับข้อมูลจากในรูปแบบของที่กำหนดไว้ก่อนหน้านี้InjectableContextTestContext

ตามทฤษฎีแล้ว เราสามารถเริ่มต้นส่วนประกอบระบบบางส่วนในเนื้อหาหลักของmochaHooksฟังก์ชันได้แล้ว สิ่งที่สำคัญคือการที่เรากรอกInjectableContextอย่างถูกต้อง — นี่คือเหตุผลที่ฉันกำหนดไว้อย่างชัดเจนในโค้ด หากคุณสงสัยว่าObject.assign(this, context);เป็นงานที่ถูกต้องหรือไม่ ใช่ เป็นการใช้งานที่ผิดปกติ แต่ทำงานได้ดี

เราจะใช้มันในการทดสอบได้อย่างไร?

การทดสอบแต่ละครั้งตามคำจำกัดความมีการเข้าถึงโดยตรงไปยังTestContextซึ่งสามารถเข้าถึงได้ในรูปแบบต่อไปนี้:

โปรดทราบว่าฟังก์ชันที่ไม่ระบุตัวตนไม่สามารถกลายเป็นฟังก์ชันลูกศรได้ มิฉะนั้น ฟังก์ชันจะไม่สามารถเข้าถึงthisวัตถุได้

สรุป

เนื่องจาก Mocha ใช้รูปแบบการออกแบบ Behavior Driven Development เราจึงต้องจัดโครงสร้างโค้ดของเราตามความเหมาะสม ต้องขอบคุณ (Root) Mocha Hooks เราจึงสามารถประกอบอุปกรณ์ได้อย่างง่ายดาย โดยได้รับทั้งสถาปัตยกรรมการทดสอบที่บำรุงรักษาได้และความปลอดภัยของประเภท หากคุณมีคำถามโปรดทิ้งไว้ในส่วนความคิดเห็น!