คำถามติดแท็ก unit-testing

หากคุณมี enum ที่มีค่าเท่านั้น (ไม่มีวิธีใดที่สามารถทำได้ใน Java) และ enum นี้เป็นส่วนหนึ่งของคำจำกัดความทางธุรกิจของระบบหนึ่งหน่วยการเขียนควรทำการทดสอบหรือไม่? ฉันคิดว่าพวกเขาควรจะเขียนแม้ว่าพวกเขาจะดูเรียบง่ายและซ้ำซ้อนฉันพิจารณาว่าสิ่งที่เกี่ยวข้องกับข้อกำหนดทางธุรกิจควรจะเขียนอย่างชัดเจนในการทดสอบไม่ว่าจะเป็นกับหน่วย / บูรณาการ / UI / ฯลฯ การทดสอบหรือโดยใช้ระบบประเภทของภาษาเป็นวิธีการทดสอบ เนื่องจากค่าที่ enum (เช่นใน Java) ต้องมีจากมุมมองของธุรกิจจึงไม่สามารถทดสอบได้โดยใช้ระบบชนิดที่ฉันคิดว่าควรมีการทดสอบหน่วยสำหรับสิ่งนั้น คำถามนี้ไม่คล้ายกับคำถามนี้เพราะมันไม่ได้แก้ปัญหาเดียวกับของฉัน ในคำถามนั้นมีฟังก์ชั่นธุรกิจ (savePeople) และบุคคลกำลังสอบถามเกี่ยวกับการใช้งานภายใน (forEach) ในนั้นมีชั้นธุรกิจกลาง (ฟังก์ชั่นบันทึกคน) encapsulating การสร้างภาษา (forEach) นี่สร้างภาษา (enum) เป็นสิ่งที่ใช้ในการระบุพฤติกรรมจากมุมมองทางธุรกิจ ในกรณีนี้รายละเอียดการใช้งานจะเกิดขึ้นพร้อมกับ "ธรรมชาติที่แท้จริง" ของข้อมูลนั่นคือ: ชุด (ในแง่คณิตศาสตร์) ของค่า คุณสามารถใช้เซตที่ไม่เปลี่ยนรูปได้ แต่ค่าเดียวกันควรยังคงอยู่ที่นั่น หากคุณใช้อาร์เรย์คุณต้องทำสิ่งเดียวกันเพื่อทดสอบตรรกะทางธุรกิจ ฉันคิดว่าปริศนาที่นี่คือความจริงที่ว่าภาษาสร้างสอดคล้องกับธรรมชาติของข้อมูลได้ดีมาก ฉันไม่แน่ใจว่าฉันอธิบายตัวเองถูกต้องหรือไม่

15 unit-testing  testing  type-systems  enum 

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

15 unit-testing  testing 

เพื่อให้เป็นตัวอย่างที่ได้รับการประดิษฐ์ขึ้นมาสมมติว่าฉันต้องการทดสอบว่าฟังก์ชันคืนค่าตัวเลขสองค่าและค่าแรกมีค่าน้อยกว่าค่าที่สอง: def test_length(): result = my_function() assert len(result) == 2 def test_order() a, b = my_function() assert a < b ที่นี่ถ้าtest_lengthล้มเหลวก็test_orderจะล้มเหลวเช่นกัน มันเป็นวิธีปฏิบัติที่ดีที่สุดในการเขียนtest_lengthหรือข้ามมัน? แก้ไข: โปรดทราบว่าในสถานการณ์นี้การทดสอบทั้งสองส่วนใหญ่เป็นอิสระจากกันการทดสอบแต่ละครั้งสามารถแยกออกจากกันหรืออาจทำงานในลำดับกลับกันสิ่งนี้ไม่สำคัญ ดังนั้นไม่มีคำถามเก่า ๆ เหล่านี้เลย ฉันจะทดสอบการทำงานของฟังก์ชั่นที่ใช้ฟังก์ชั่นอื่น ๆ ในนั้นได้อย่างไร? ฉันจำเป็นต้องมีการทดสอบหน่วยหรือไม่ถ้าฉันมีการทดสอบการรวมระบบอยู่แล้ว? วิธีจัดโครงสร้างการทดสอบโดยที่การทดสอบครั้งหนึ่งเป็นการตั้งค่าการทดสอบอื่น? วิธีจัดการการพึ่งพาความสำเร็จระหว่างการทดสอบหน่วย เป็นคู่ที่ซ้ำกันของข้างต้น

15 unit-testing 

ฉันมีประสบการณ์มากกว่า 2 ปีในการพัฒนาแอพพลิเคชั่น ในสองปีที่ผ่านมาแนวทางการพัฒนาของฉันมีดังต่อไปนี้ วิเคราะห์ข้อกำหนด Identity Core องค์ประกอบ / วัตถุฟังก์ชันที่จำเป็น, พฤติกรรม, กระบวนการและข้อ จำกัด สร้างคลาสความสัมพันธ์ระหว่างพวกเขาข้อ จำกัด เกี่ยวกับพฤติกรรมของวัตถุ & รัฐ สร้างฟังก์ชั่นการประมวลผลด้วยข้อ จำกัด พฤติกรรมตามความต้องการ ทดสอบแอปพลิเคชันด้วยตนเอง หากความต้องการเปลี่ยนแปลงแก้ไของค์ประกอบ / ฟังก์ชั่นให้ทดสอบโปรแกรมด้วยตนเอง เมื่อเร็ว ๆ นี้ฉันได้รับการแนะนำให้รู้จักกับ TDD และรู้สึกว่านี่เป็นวิธีที่ดีมากในการพัฒนาเนื่องจากโค้ดที่พัฒนาแล้วมีเหตุผลที่แข็งแกร่งที่มีอยู่ แต่ปัญหาของฉันคือฉันไม่สามารถสร้างการทดสอบก่อนได้ แต่ฉันจะระบุส่วนประกอบและเพียงแค่เขียนการทดสอบสำหรับพวกเขาก่อนที่ฉันจะเขียนส่วนประกอบจริง ๆ คำถามของฉันคือ ฉันทำถูกไหม? ถ้าไม่ใช่สิ่งที่ฉันต้องเปลี่ยนแน่นอน มีวิธีใดที่คุณสามารถระบุได้ว่าแบบทดสอบที่คุณเขียนนั้นเพียงพอหรือไม่ เป็นการดีหรือไม่ที่จะทดสอบการเขียนสำหรับฟังก์ชั่นที่ง่ายมากซึ่งอาจเทียบเท่ากับ 1 + 1 = 2 หรือเป็นเพียงภาพซ้อนทับ? มันเป็นการดีที่จะเปลี่ยนฟังก์ชั่นและตามการทดสอบว่ามีการเปลี่ยนแปลงข้อกำหนด?

15 programming-practices  unit-testing  tdd  acceptance-testing 

ฉันรู้ว่านี่เป็นวิธีปฏิบัติที่ถกเถียงกัน แต่สมมติว่านี่เป็นตัวเลือกที่ดีที่สุดสำหรับฉัน ฉันสงสัยเกี่ยวกับเทคนิคที่แท้จริงในการทำสิ่งนี้ วิธีการที่ฉันเห็นคือ: 1) สร้างคลาสเพื่อนที่เป็นคลาสที่ฉันต้องการทดสอบ 2) ในคลาสเพื่อนสร้างวิธีสาธารณะที่เรียกวิธีส่วนตัวของคลาสที่ทดสอบ 3) ทดสอบวิธีสาธารณะของเพื่อนชั้น นี่เป็นตัวอย่างง่ายๆที่แสดงให้เห็นถึงขั้นตอนข้างต้น: #include <iostream> class MyClass { friend class MyFriend; // Step 1 private: int plus_two(int a) { return a + 2; } }; class MyFriend { public: MyFriend(MyClass *mc_ptr_1) { MyClass *mc_ptr = mc_ptr_1; } int plus_two(int a) // Step …

15 c++  unit-testing  class  c++11 

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

15 testing  unit-testing  integration-tests  test-coverage 

ฉันกำลังพยายามสร้างกรณีทดสอบและได้อ่านว่าคุณควรลองและ จำกัด จำนวนการยืนยันต่อกรณีทดสอบ ดังนั้นคำถามของฉันคือวิธีที่ดีที่สุดในการทดสอบฟังก์ชั่นที่มีอินพุตหลายอินพุต ตัวอย่างเช่นฉันมีฟังก์ชั่นที่แยกวิเคราะห์สตริงจากผู้ใช้และส่งกลับจำนวนนาที สตริงสามารถอยู่ในรูปแบบ"5w6h2d1m"ที่w, h, d, mสอดคล้องกับจำนวนสัปดาห์ชั่วโมงวันและนาที หากฉันต้องการปฏิบัติตาม 'การยืนยันที่ 1 ต่อกฎการทดสอบ' ฉันต้องทำการทดสอบหลายอย่างสำหรับแต่ละรูปแบบของอินพุตหรือไม่ ดูเหมือนว่างี่เง่าดังนั้นฉันจึงมีบางอย่างเช่น self.assertEqual(parse_date('5m'), 5) self.assertEqual(parse_date('5h'), 300) self.assertEqual(parse_date('5d') ,7200) self.assertEqual(parse_date('1d4h20m'), 1700) ในกรณีทดสอบหนึ่ง มีวิธีที่ดีกว่า?

15 testing  unit-testing 

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

15 programming-languages  design  object-oriented  unit-testing  terminology 

ฉันทำงานกับแอพพลิเคชั่นหลายตัว ปัจจุบันการครอบคลุมโค้ดของพวกเขาค่อนข้างต่ำ: โดยทั่วไประหว่าง 10 และ 50% ตั้งแต่หลายสัปดาห์เราได้พูดคุยกับทีมงานบังกาลอร์ (ส่วนหลักของการพัฒนาในต่างประเทศในอินเดีย) เกี่ยวกับการยกเว้นแพคเกจหรือคลาสสำหรับ Cobertura (เครื่องมือครอบคลุมรหัสของเราแม้ว่าเราจะย้ายไปที่ JaCoCo) มุมมองของพวกเขามีดังต่อไปนี้เนื่องจากพวกเขาจะไม่เขียนการทดสอบหน่วยใด ๆ ในบางเลเยอร์ของแอปพลิเคชัน(1)เลเยอร์เหล่านี้ควรแยกออกจากการวัดความครอบคลุมของรหัส ในคำพูดของคนอื่น ๆ ที่พวกเขาต้องการที่จะ จำกัด การวัดความคุ้มครองรหัสเพื่อรหัสที่มีการทดสอบหรือควรจะทดสอบ นอกจากนี้เมื่อพวกเขาทดสอบหน่วยการเรียนสำหรับคลาสที่ซับซ้อนประโยชน์ที่ได้รับซึ่งล้วน แต่ครอบคลุมในเรื่องการครอบคลุมโค้ดนั้นจะไม่ถูกสังเกตเห็นในแอปพลิเคชันขนาดใหญ่ การลดขอบเขตของการครอบคลุมโค้ดจะทำให้ความพยายามในลักษณะนี้ชัดเจนยิ่งขึ้น ... ที่น่าสนใจของวิธีนี้คือการที่เราจะมีมาตรการคุ้มครองรหัสที่บ่งชี้ว่าสถานะปัจจุบันของส่วนหนึ่งของโปรแกรมที่เราพิจารณาเป็นทดสอบ อย่างไรก็ตามมุมมองของฉันคือเรากำลังแกล้งทำตัวเลข โซลูชันนี้เป็นวิธีที่ง่ายในการเข้าถึงระดับการครอบคลุมโค้ดที่สูงขึ้นโดยไม่ต้องใช้ความพยายามใด ๆ อีกประเด็นหนึ่งที่ทำให้ฉันรำคาญใจคือ: ถ้าเราแสดงความครอบคลุมที่เพิ่มขึ้นจากหนึ่งสัปดาห์ไปอีกหนึ่งสัปดาห์เราจะบอกได้อย่างไรว่าข่าวดีนี้เกิดจากการทำงานที่ดีของนักพัฒนาหรือเกิดจากการยกเว้นใหม่ นอกจากนี้เราจะไม่สามารถทราบได้อย่างชัดเจนถึงสิ่งที่ถูกพิจารณาในการวัดความครอบคลุมโค้ด ตัวอย่างเช่นถ้าฉันมี 10,000 เส้นของการประยุกต์ใช้รหัสที่มี 40% ของความคุ้มครองรหัสผมสามารถหักค่าใช้จ่ายที่ 40% ของฐานรหัสของฉันมีการทดสอบ(2) แต่จะเกิดอะไรขึ้นถ้าเราตั้งค่าการยกเว้น หากรหัสครอบคลุมอยู่ในขณะนี้ 60% ฉันจะหักอะไรได้แน่ มีการทดสอบ 60% ของรหัสฐาน "สำคัญ" ของฉันหรือไม่ ฉันสามารถ เท่าที่ฉันเป็นห่วงฉันชอบที่จะรักษาคุณค่าของรหัส "ของจริง" …

15 unit-testing  code-quality 

ฉันต้องการถามคนอื่น ๆ ว่าในกรณีนี้การทดสอบหน่วยการพิมพ์แบบสแตติกทำงานได้ดีตามที่เขียนใน haskell, scala, ocaml, nemerle, f # หรือ haXe (สุดท้ายคือสิ่งที่ฉันสนใจจริงๆ แต่ฉันต้องการ แตะเข้าไปในความรู้ของชุมชนที่ใหญ่กว่า) ฉันถามสิ่งนี้เพราะจากความเข้าใจของฉัน: ด้านหนึ่งของการทดสอบหน่วยคือการมีรายละเอียดในรูปแบบที่รันได้ อย่างไรก็ตามเมื่อใช้รูปแบบการประกาศที่แมปข้อมูลจำเพาะอย่างเป็นทางการกับความหมายของภาษาเป็นไปได้หรือไม่ที่จริงแล้วมันเป็นไปได้หรือไม่ที่จะแสดงรายละเอียดในรูปแบบที่รันได้ในวิธีที่แยกจากกัน ลักษณะที่ชัดเจนของการทดสอบหน่วยคือการติดตามข้อผิดพลาดที่ไม่สามารถเปิดเผยได้ผ่านการวิเคราะห์แบบคงที่ เนื่องจากรหัสการทำงานที่ปลอดภัยประเภทนั้นเป็นเครื่องมือที่ดีในการเขียนโค้ดที่ใกล้เคียงกับที่ตัววิเคราะห์สถิตของคุณเข้าใจมากดูเหมือนว่าคุณสามารถเปลี่ยนความปลอดภัยไปสู่การวิเคราะห์แบบสถิต อย่างไรก็ตามข้อผิดพลาดง่าย ๆ เช่นการใช้xแทนy(ทั้งคู่เป็นพิกัด) ในรหัสของคุณไม่สามารถครอบคลุม ความผิดพลาดดังกล่าวอาจเกิดขึ้นในขณะที่เขียนรหัสทดสอบดังนั้นฉันไม่แน่ใจว่ามันคุ้มค่ากับความพยายามหรือไม่ การทดสอบหน่วยจะนำเสนอความซ้ำซ้อนซึ่งหมายความว่าเมื่อต้องการเปลี่ยนแปลงรหัสการใช้งานและการทดสอบที่ครอบคลุมรหัสนี้จะต้องเปลี่ยนทั้งคู่ แน่นอนว่าค่าโสหุ้ยนี้เป็นเรื่องเกี่ยวกับค่าคงที่ดังนั้นเราจึงสามารถโต้แย้งได้ว่ามันไม่สำคัญ ในความเป็นจริงในภาษาอย่าง Ruby นั้นไม่ได้เปรียบเทียบกับประโยชน์ที่ได้รับ แต่เนื่องจากการเขียนโปรแกรมเชิงฟังก์ชันที่ครอบคลุมการทดสอบหน่วยภาคพื้นดินจำนวนมากนั้นมีจุดประสงค์เพื่อให้ความรู้สึกว่าเป็นค่าใช้จ่ายที่คงที่เพียงอย่างเดียว จากนี้ฉันจะอนุมานว่าการทดสอบหน่วยค่อนข้างล้าสมัยในรูปแบบการเขียนโปรแกรมนี้ แน่นอนว่าการอ้างสิทธิ์ดังกล่าวสามารถนำไปสู่สงครามศาสนาเท่านั้นดังนั้นให้ฉันตั้งคำถามนี้ง่ายๆ เมื่อคุณใช้รูปแบบการเขียนโปรแกรมคุณใช้ขอบเขตการทดสอบแบบใดและเพราะเหตุใด (คุณหวังว่าจะได้คุณภาพสำหรับโค้ดของคุณ) หรือในทางกลับกัน: คุณมีเกณฑ์ที่คุณสามารถมีคุณสมบัติหน่วยของรหัสการทำงานแบบคงที่ตามที่ครอบคลุมโดยตัววิเคราะห์แบบคงที่และโดยไม่จำเป็นต้องครอบคลุมการทดสอบหน่วย?

15 unit-testing  functional-programming  tdd  haskell  scala 

ฉันดูการนำเสนอของ Google Tech Talk เกี่ยวกับการทดสอบหน่วยที่ Misko Hevery มอบให้และเขาบอกว่าเพื่อหลีกเลี่ยงการใช้newคำหลักในรหัสตรรกะทางธุรกิจ ฉันเขียนโปรแกรมและท้ายที่สุดฉันก็ใช้newคำหลักที่นี่และที่นั่น แต่ส่วนใหญ่สำหรับการทำอินสแตนซ์วัตถุที่เก็บข้อมูล (เช่นพวกเขาไม่มีฟังก์ชั่นหรือวิธีการใด ๆ ) ฉันสงสัยว่าฉันทำอะไรผิดหรือเปล่าเมื่อฉันใช้คำหลักใหม่สำหรับโปรแกรมของฉัน และเราจะทำลาย 'กฎ' นั้นได้ที่ไหน

15 testing  unit-testing 

เมื่อเร็ว ๆ นี้ในที่ทำงานที่เราได้รับมีความแตกต่างบางส่วนของความเห็นเกี่ยวกับการที่มีการทดสอบ Parameterized โดยปกติเราใช้สไตล์ TDD (หรืออย่างน้อยพยายาม) เพื่อให้ฉันเข้าใจถึงประโยชน์ของการอนุมัตินั้น อย่างไรก็ตามฉันพยายามดิ้นรนเพื่อดูการทดสอบที่ได้รับจากพารามิเตอร์ สำหรับการอ้างอิงเราทำงานกับบริการและเป็นห้องสมุดที่เปิดเผยผ่านอินเตอร์เฟส RESTful สิ่งที่ฉันเคยเห็นคือการทดสอบอย่างน้อยก็ใช้ JUnit ภายใน Eclipse: รายละเอียดการขาด - เมื่อการทดสอบล้มเหลวมันเป็นเรื่องยากมากที่จะเห็นพารามิเตอร์ที่ทำให้มันล้มเหลว มักจะสร้างความซับซ้อน มีแนวโน้มที่จะถูกสร้างขึ้นหลังจากเขียนโค้ด - ไม่ใช่ข้อเสียเปรียบเช่นนี้ แต่ผู้คนเริ่มต้นด้วยการทดสอบแบบกำหนดพารามิเตอร์ไว้ในใจเมื่อพวกเขาเริ่มเขียนโค้ดหรือไม่? หากใครมีตัวอย่างของที่พวกเขามีประโยชน์จริง ๆ หรือแม้แต่คำแนะนำที่ดีสำหรับการใช้พวกเขาที่จะยอดเยี่ยม ฉันต้องการให้แน่ใจว่าฉันไม่เพียง แต่ถูกดื้อรั้นเพราะฉันไม่ได้เลือกที่จะใช้พวกเขาและดูว่าพวกเขาเป็นสิ่งที่เราควรพิจารณาเป็นส่วนหนึ่งของคลังแสงทดสอบของเราหรือไม่

15 testing  unit-testing 

ตามที่เป็นอยู่ในปัจจุบันคำถามนี้ไม่เหมาะสำหรับรูปแบบคำถาม & คำตอบของเรา เราคาดหวังคำตอบที่จะได้รับการสนับสนุนจากข้อเท็จจริงการอ้างอิงหรือความเชี่ยวชาญ แต่คำถามนี้อาจเรียกร้องให้มีการถกเถียงอภิปรายโต้แย้งหรือการอภิปรายเพิ่มเติม หากคุณรู้สึกว่าคำถามนี้สามารถปรับปรุงและเปิดใหม่ได้โปรดไปที่ศูนย์ช่วยเหลือเพื่อขอคำแนะนำ ปิดให้บริการใน6 ปีที่ผ่านมา ฉันต้องการลองใช้ TDD บางอย่างในเว็บแอปพลิเคชันของเราเพื่อลดการถดถอยและปรับปรุงคุณภาพการเผยแพร่ แต่ฉันไม่มั่นใจว่าการทดสอบอัตโนมัติจะทำงานได้ดีเพียงใดกับแอปพลิเคชันทางเว็บ ฉันได้อ่านเกี่ยวกับและลองใช้ TDD และการทดสอบหน่วย แต่ตัวอย่างก็คือฟังก์ชั่น 'ที่เป็นของแข็ง' และค่อนข้างง่ายเช่นตัวแปลงสกุลเงินเป็นต้น มีทรัพยากรใดบ้างที่สามารถช่วยในการทดสอบหน่วยการจัดการเนื้อหาและระบบสิ่งพิมพ์? หน่วยทดสอบตะกร้าสินค้า / ร้านค้า (ผลิตภัณฑ์จริงและออนไลน์) เป็นอย่างไร AJAX? Googling สำหรับ "การพัฒนาเว็บทดสอบการขับเคลื่อน" ทำให้ฉันได้รับบทความเก่า ๆ เมื่อหลายปีก่อนโดยครอบคลุมตัวอย่างเดียวกันของฟังก์ชั่นเหมือนเครื่องคิดเลขหรือการอภิปรายเกี่ยวกับสาเหตุที่ TDD ดีกว่าอะไร (โดยไม่มีตัวอย่าง)

15 web-development  unit-testing  web-applications  tdd 

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

15 unit-testing  code-reviews 

ฉันไม่เคยมั่นใจในข้อดีที่คุณได้รับจากการเปลี่ยนไปใช้ RSpec จาก Test :: Unit ใน Ruby on Rails (แม้จะอ่านเกี่ยวกับ RSpec เป็นครั้งคราว) มันเกี่ยวกับ RSpec ที่โครงการ Rails ส่วนใหญ่ดูเหมือนว่าจะใช้หรือไม่ (ตัวอย่างโค้ดบางตัวอย่างที่แสดงให้เห็นข้อดีอย่างชัดเจนของอีกอันหนึ่งจะได้รับการชื่นชมมาก)

15 testing  unit-testing  ruby-on-rails