ถือว่าเป็น 'การปฏิบัติที่ไม่เหมาะสม' เพื่อตรวจสอบเนื้อหาของไฟล์ / การเข้ารหัสในการทดสอบหน่วยหรือไม่?

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

• ไม่ว่าด้วยเหตุผลใดก็ตามไฟล์ ASCII นั้นถูกเข้ารหัสใน UTF-16 (เพื่อนร่วมงานได้ส่งไฟล์ให้ฉันทางอีเมลซึ่งอาจเป็นสาเหตุให้เกิดปัญหา)
• สคริปต์ขาดSETคำสั่งเริ่มต้น(จำเป็นเนื่องจากมีบางสิ่งที่ไดรเวอร์อยู่ในการผลิต แต่ไม่ใช่ในการติดตั้งใหม่ทั้งหมด)

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

อย่างไรก็ตามเมื่อฉันส่งรหัสนี้ให้เพื่อนร่วมงานคนอื่น (ซึ่งเป็นหัวหน้าทีมของเราด้วย) ก็เดินมาหาฉันและบอกฉันว่าฉันไม่ควรทำสิ่งเหล่านี้อีกเพราะ:

"สิ่งเหล่านี้ไม่ได้อยู่ในการทดสอบหน่วย"

"การทดสอบหน่วยควรใช้เพื่อตรวจสอบการไหลของรหัสของคุณ"

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

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

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

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

ปัญหาที่ฉันพยายามแก้ไขคืออะไร

โดยคำอธิบายคุณต้องตรวจสอบว่าสคริปต์ฐานข้อมูลใด ๆ ปฏิบัติตามมาตรฐานบางอย่าง

มีเครื่องมือ / กระบวนการใดบ้างที่สามารถใช้แก้ปัญหาได้

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

หากคุณสร้างส่วนหนึ่งของโครงสร้างพื้นฐานการสร้างของคุณเช่นการรวมไว้ใน Jenkins หรืออะไรทำนองนั้นมันสามารถใช้กับไฟล์ SQL ทั้งหมดในโครงการของคุณ

หน่วยทดสอบจะแก้ปัญหาสำหรับไฟล์ปัจจุบันของคุณเท่านั้น

ฉันจะสื่อสารความต้องการเครื่องมือได้อย่างไร

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

กลุ่มเป้าหมายของคุณอาจมีแนวคิดบางอย่างที่คุณ (หรือฉัน) ไม่ได้พิจารณาซึ่งสามารถแก้ไขปัญหาได้อย่างถูกต้องมากขึ้น

เป็นการดีที่จะเรียกใช้การทดสอบที่เข้าถึงไฟล์ "การทดสอบหน่วย"

เขา: "สิ่งเหล่านี้ไม่ได้อยู่ในการทดสอบหน่วย"

คุณ: "เข้าท่า แต่ฉันไม่สามารถหาที่ที่ดีกว่าที่จะวางพวกเขาพวกเขาอยู่ที่ไหน?"

น่าเสียดายที่การทดสอบประเภทใดที่มีอยู่และวิธีการจัดระเบียบนั้นมีเฉพาะ บริษัท ทั้งหมด ดังนั้นคุณจะต้องค้นหาวิธีที่ บริษัท ของคุณจัดการกับการทดสอบเหล่านี้

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

Michael Feathers กล่าวสิ่งนี้ในหนังสือของเขาที่ทำงานอย่างมีประสิทธิภาพด้วยรหัสเดิม:

ในอุตสาหกรรมนี้ผู้คนมักจะเดินทางไปมาว่าการทดสอบนั้นเป็นการทดสอบหน่วยหรือไม่ [... ] ฉันกลับไปที่คุณสมบัติสองประการ: การทดสอบรันเร็วหรือไม่? มันสามารถช่วยเราแปลข้อผิดพลาดได้อย่างรวดเร็วหรือไม่?

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

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

ฉันได้เขียนการทดสอบที่คล้ายกันในบางครั้งกับไฟล์รหัสต้นฉบับไฟล์การกำหนดค่าและอื่น ๆ ฉันจะไม่เรียกพวกเขาว่าการทดสอบหน่วยเพราะ (a) พวกเขากำลังเข้าถึงระบบไฟล์และอาจไม่เร็วมาก (b) ฉันไม่สนใจว่าพวกเขาจะถูกดำเนินการในทุกการเช็คอิน (ตรงข้ามกับทุกคืนใน เซิร์ฟเวอร์ CI)

คุณอาจเรียกพวกเขาว่าการทดสอบการรวม แน่นอนพวกเขาอยู่ใกล้กับมุมมองนั้นมากกว่าการทดสอบหน่วย

ระยะของตัวเองสำหรับพวกเขาคือการทดสอบทรัพยากร IMHO พวกเขามีความชอบธรรมอย่างสมบูรณ์หากดำเนินการทุกคืนบนเซิร์ฟเวอร์ CI: มีค่าใช้จ่ายน้อยที่สุดและเมื่อใช้อย่างมีเหตุผลควรเพิ่มมูลค่าอย่างชัดเจน คำจำกัดความหนึ่งของความรอบคอบ : หากการทดสอบกำลังตรวจสอบปัญหาที่ทำให้เกิดปัญหา (เช่นการเข้ารหัสที่คุณพูดถึง)

การทดสอบหน่วยนั้นเกี่ยวกับการทดสอบวิธีการหรือ 'หน่วย' ของรหัส คุณกำลังทดสอบกลุ่มตรรกะและรหัสที่เล็กที่สุดในซอฟต์แวร์ของคุณ

ต่อมาเมื่อคุณเข้าร่วมกับหน่วยอื่นคุณจะทำการทดสอบการรวม

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

SQL ของคุณเป็นรหัสเช่นเดียวกับภาษาที่มีระดับต่ำกว่าเช่น C # หรือ Java และควรทดสอบเช่นนี้ และการตรวจสอบและการตรวจสอบเป็นของทุกระดับการทดสอบ ดังนั้นการเข้ารหัสและชุดคำสั่ง SET จึงรวมอยู่ด้วย แต่ไม่จำเป็นต้องทำการทดสอบอย่างเฉพาะเจาะจง สิ่งทั่วไปเช่นการจบบรรทัดหรือการปิดล้อมคุณสามารถใช้ตะขอหรือคุณสมบัติ SCM

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

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

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

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

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

อย่างไรก็ตามมันอาจไม่ใช่การทดสอบหน่วย แต่เป็นการทดสอบที่มีประโยชน์ และถ้าคุณใช้กรอบการทดสอบหน่วยที่อนุญาตให้คุณทำการทดสอบที่มีประโยชน์ (นั่นไม่ใช่การทดสอบหน่วย) ทำไมไม่ใช้กรอบการทดสอบหน่วย

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

git add -p

สิ่งนี้จะทำให้การเปลี่ยนแปลงในไฟล์ข้อความแต่ละไฟล์ไดเรกทอรีทำงานถามคุณว่าคุณต้องการเก็บไว้หรือไม่ ที่จะช่วยให้คุณเห็นเช่นการลบในบรรดา“เริ่มต้นSETงบ”

ในกรณีที่การเข้ารหัสไฟล์ทั้งหมดเปลี่ยนแปลงสิ่งต่าง ๆ จะเกิดขึ้น: อัลกอริทึมจะล้มเหลวในการกระจายไฟล์เก่าและใหม่ดังนั้นจึงgit add -pไม่เพิ่มอะไรเลย นี่จะปรากฏให้เห็นในคำสั่งอื่นที่ฉันทำก่อนการกระทำใด ๆ คือ

git status

ที่นี่คุณจะได้เห็นไฟล์เน้นด้วยสีแดงแสดงให้เห็นว่ามีมีการเปลี่ยนแปลง การตรวจสอบว่าทำไมสิ่งเหล่านี้ไม่ได้ทำให้git add -pเกิดปัญหาอย่างรวดเร็วจะทำให้ชัดเจน

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

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

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

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

ประการแรก - หนึ่งในจุดประสงค์ของการทดสอบคือการป้องกันไม่ให้เกิดปัญหาซ้ำในรหัสของคุณ - ดังนั้นคุณควรทำการทดสอบการเขียนในลักษณะนี้

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

ดังนั้นคำถามคือ (ควรอยู่ในบริบทของคุณ) มากขึ้นเกี่ยวกับเวลาและวิธีการทดสอบเหล่านี้จะทำงานมากกว่าสิ่งที่พวกเขาเป็น

ฉันเคยใช้การทดสอบประเภทนี้อย่างกว้างขวางในอดีต - พวกเขาได้ช่วยเราเจ็บปวดอันเจ็บปวด

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

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

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

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