ไฟล์เดียวหรือหลายไฟล์สำหรับการทดสอบหน่วยในชั้นเดียว?

ในการวิจัยการทดสอบแนวปฏิบัติที่ดีที่สุดเพื่อช่วยรวบรวมแนวทางสำหรับองค์กรของฉันฉันพบว่ามันดีกว่าหรือมีประโยชน์ในการแยกการทดสอบการทดสอบ (คลาสทดสอบ) หรือเพื่อทำการทดสอบทั้งหมดสำหรับคลาสเดียวในไฟล์เดียว

Fwiw ฉันหมายถึง "การทดสอบหน่วย" ในความหมายที่บริสุทธิ์ว่าเป็นการทดสอบในกล่องสีขาวที่กำหนดเป้าหมายไปที่คลาสเดี่ยวหนึ่งการยืนยันต่อการทดสอบหนึ่งการอ้างอิงทั้งหมดที่ล้อเลียนเป็นต้น

ตัวอย่างสถานการณ์เป็นคลาส (เรียกว่าเอกสาร) ที่มีสองวิธี: CheckIn และ CheckOut แต่ละวิธีใช้กฎต่าง ๆ ฯลฯ ที่ควบคุมพฤติกรรมของพวกเขา ตามกฎข้อหนึ่งต่อการทดสอบฉันจะมีการทดสอบหลายวิธีสำหรับแต่ละวิธี ฉันสามารถวางทั้งหมดของการทดสอบในครั้งเดียวDocumentTestsระดับที่มีชื่อชอบและCheckInShouldThrowExceptionWhenUserIsUnauthorizedCheckOutShouldThrowExceptionWhenUserIsUnauthorized

หรือผมอาจจะมีสองชั้นทดสอบเฉพาะกิจการ: และCheckInShould CheckOutShouldในกรณีนี้ชื่อการทดสอบของฉันจะสั้นลง แต่พวกเขาจะจัดระเบียบเพื่อให้การทดสอบทั้งหมดสำหรับพฤติกรรมที่เฉพาะเจาะจง (วิธีการ) อยู่ด้วยกัน

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

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

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

1. ไม่จำเป็นต้องทำซ้ำ (และเก็บรักษารหัสการตั้งค่าหลายรุ่น)
2. ง่ายกว่าในการรันการทดสอบทั้งหมดสำหรับคลาสจาก IDE หากพวกเขาเป็นกลุ่มในหนึ่งคลาสทดสอบ
3. การแก้ไขปัญหาที่ง่ายขึ้นด้วยการทำแผนที่แบบหนึ่งต่อหนึ่งระหว่างคลาสการทดสอบและคลาส

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

นอกจากนี้การยอมรับชื่อเมธอดที่ยาวกว่าในการทดสอบหน่วยนั้นเป็นสิ่งที่ยอมรับได้ แต่ถ้ามันรบกวนจิตใจคุณคุณสามารถคิดทบทวนแผนการตั้งชื่อการทดสอบหน่วยของคุณอีกครั้งเพื่อย่อชื่อ

หนึ่งในข้อโต้แย้งของฉันต่อการแยกการทดสอบออกเป็นหลายคลาสคือมันยากสำหรับนักพัฒนาคนอื่น ๆ ในทีม (โดยเฉพาะผู้ที่ไม่เข้าใจการทดสอบ) เพื่อค้นหาการทดสอบที่มีอยู่ ( Gee ฉันสงสัยว่ามีการทดสอบนี้หรือไม่ ฉันสงสัยว่ามันจะเป็นยังไง? ) และอีกที่จะทำการทดสอบใหม่ ( ฉันจะเขียนการทดสอบสำหรับวิธีการนี้ในคลาสนี้ แต่ไม่แน่ใจว่าฉันควรใส่ไว้ในไฟล์ใหม่หรือที่มีอยู่แล้ว หนึ่ง )

ในกรณีที่การทดสอบที่แตกต่างกันต้องการการตั้งค่าที่แตกต่างกันอย่างมากฉันได้เห็นผู้ปฏิบัติงานของ TDD บางคนใส่ "ฟิกซ์เจอร์" หรือ "การตั้งค่า" ในคลาส / ไฟล์ต่าง ๆ แต่ไม่ใช่การทดสอบด้วยตนเอง

ฉันหวังว่าฉันจะจำ / ค้นหาลิงก์ที่แสดงให้เห็นว่าเทคนิคที่ฉันเลือกที่จะนำมาใช้ครั้งแรก โดยพื้นฐานแล้วฉันสร้างคลาสนามธรรมที่เป็นนามธรรมสำหรับแต่ละคลาสภายใต้การทดสอบที่มีการทดสอบซ้อนกัน (คลาส) สำหรับสมาชิกแต่ละคนที่กำลังทดสอบ สิ่งนี้จะให้การแยกเดิมที่ต้องการ แต่เก็บการทดสอบทั้งหมดไว้ในไฟล์เดียวกันสำหรับแต่ละตำแหน่ง นอกจากนี้ยังสร้างชื่อคลาสที่ช่วยให้การจัดกลุ่มและการเรียงลำดับในตัวทดสอบทดสอบทำได้ง่าย

นี่คือตัวอย่างวิธีใช้วิธีการนี้กับสถานการณ์เดิมของฉัน:

public abstract class DocumentTests : TestBase
{
    [TestClass()]
    public sealed class CheckInShould : DocumentTests
    {
        [TestMethod()]
        public void ThrowExceptionWhenUserIsNotAuthorized()
        {
        }
    }

    [TestClass()]
    public sealed class CheckOutShould : DocumentTests
    {
        [TestMethod()]
        public void ThrowExceptionWhenUserIsNotAuthorized()
        {
        }
    }
}

ผลลัพธ์นี้ในการทดสอบต่อไปนี้ปรากฏในรายการทดสอบ:

DocumentTests+CheckInShould.ThrowExceptionWhenUserIsNotAuthorized
DocumentTests+CheckOutShould.ThrowExceptionWhenUserIsNotAuthorized

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

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

ลองคิดวิธีอื่น ๆ ประมาณหนึ่งนาที

ทำไมคุณต้องมีหนึ่งคลาสทดสอบต่อหนึ่งคลาส? คุณกำลังทำการทดสอบในชั้นเรียนหรือการทดสอบหน่วย? คุณขึ้นอยู่กับชั้นเรียนด้วยหรือไม่

การทดสอบหน่วยควรจะทดสอบพฤติกรรมที่เฉพาะเจาะจงในบริบทที่เฉพาะเจาะจง ความจริงที่ว่าชั้นเรียนของคุณมีCheckInวิธีการที่ควรมีพฤติกรรมที่ต้องการในสถานที่แรก

คุณคิดยังไงกับรหัสหลอกนี้:

// check_in_test.file

class CheckInTest extends TestCase {
        /** @test */
        public function unauthorized_users_cannot_check_in() {
                $this->expectException();

                $document = new Document($unauthorizedUser);

                $document->checkIn();
        }
}

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

ไฟล์ทดสอบหนึ่งไฟล์สำหรับหนึ่งคลาสทำให้ยากต่อการปรับโครงสร้างใหม่เมื่อใดก็ตามที่คุณต้องการและการทดสอบก็ไม่สมเหตุสมผลในด้านโดเมน / ตรรกะของโค้ดเอง

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

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

1. พิจารณาสิ่งที่น่าจะผิดพลาด

ในระหว่างการพัฒนาเริ่มแรกคุณรู้ดีว่าคุณกำลังทำอะไรและทั้งสองวิธีอาจจะใช้ได้

มันน่าสนใจมากขึ้นเมื่อการทดสอบล้มเหลวหลังจากการเปลี่ยนแปลงในภายหลัง มีความเป็นไปได้สองอย่าง:

1. คุณเสียอย่างจริงจังCheckIn(หรือCheckOut) อีกครั้งทั้งไฟล์เดี่ยวและโซลูชันสองไฟล์ก็โอเคในกรณีนั้น
2. คุณได้ปรับเปลี่ยนทั้งสองCheckInและCheckOut(และอาจทดสอบ) ในลักษณะที่เหมาะสมสำหรับแต่ละคน แต่ไม่ใช่สำหรับทั้งสองเข้าด้วยกัน คุณหักการเชื่อมโยงของคู่ ในกรณีดังกล่าวการแยกการทดสอบมากกว่าสองไฟล์จะทำให้ยากต่อการเข้าใจปัญหา

2. พิจารณาว่าจะใช้การทดสอบแบบใด

การทดสอบมีจุดประสงค์หลักสองประการ:

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

ดังนั้น?

ทั้งสองมุมมองเหล่านี้แนะนำให้ทำการทดสอบด้วยกันสามารถช่วยได้ แต่จะไม่เจ็บ