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

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

16 unit-testing  testing  tdd  integration-tests  acceptance-testing 

ฉันต้องการส่งคำถามนี้ออกไปเพื่อดูว่าสื่ออยู่ที่ไหนอย่างน่าสนใจ ฉันจะยอมรับว่าในช่วง 12 เดือนที่ผ่านมาฉันเลือก TDD และค่า Agile จำนวนมากในการพัฒนาซอฟต์แวร์ ฉันรู้สึกสับสนมากกับการพัฒนาซอฟต์แวร์ที่ดีขึ้นเรื่อย ๆ จนฉันไม่เคยละทิ้งพวกเขาออกจากหลักการ จนกระทั่ง ... ฉันได้รับการเสนอบทบาทการทำสัญญาที่สองเท่าของฉันกลับบ้านจ่ายสำหรับปี บริษัท ที่ฉันเข้าร่วมไม่ได้ทำตามวิธีการเฉพาะใด ๆ ทีมไม่เคยได้ยินอะไรเลยเช่นกลิ่นรหัส SOLID ฯลฯ และแน่นอนว่าฉันจะไม่ใช้เวลากับการทำ TDD หากทีมไม่เคยแม้แต่จะทำ เห็นการทดสอบหน่วยในทางปฏิบัติ ฉันขายของหมดแล้วหรือยัง ไม่ไม่สมบูรณ์ ... รหัสจะถูกเขียนว่า "หมดจด" เสมอ (ตามคำสอนของลุงบ็อบ) และหลักการของ SOLID จะถูกนำไปใช้กับรหัสที่ฉันเขียนตามที่พวกเขาต้องการเสมอ การทดสอบลดลงสำหรับฉัน แต่ บริษัท ไม่สามารถที่จะส่งทีมที่ไม่รู้จักเช่นคนที่ค่อนข้างตรงไปตรงมาแม้ว่าฉันจะสร้างกรอบการทดสอบพวกเขาจะไม่ใช้ / บำรุงรักษากรอบการทดสอบอย่างถูกต้อง การใช้สิ่งนั้นเป็นตัวอย่างคุณจะบอกว่านักพัฒนาไม่ควรทิ้งหลักการฝีมือของเขาเพื่อเงิน / ผลประโยชน์อื่น ๆ ฉันเข้าใจว่านี่อาจเป็นความเห็นส่วนตัวเกี่ยวกับความกังวลของพวกเขาต่อความต้องการทางธุรกิจและประโยชน์ของงานฝีมือ ฯลฯ แต่เราสามารถพิจารณาได้ว่าตัวอย่างเช่นการทดสอบอาจตกถ้า บริษัท ตัดสินใจว่าพวกเขาต้องการ ทีมทดสอบแทนที่จะเข้าใจการทดสอบหน่วยในการเขียนโปรแกรมนั่นเป็นสิ่งที่คุณสามารถยกโทษให้ตัวเองได้หรือไม่? …

16 agile  testing  unit-testing  tdd  sdlc 

ปิด คำถามนี้เป็นคำถามความคิดเห็นตาม ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้สามารถตอบข้อเท็จจริงและการอ้างอิงได้โดยแก้ไขโพสต์นี้ ปิดให้บริการใน5 ปีที่ผ่านมา โดยเฉพาะอย่างยิ่งเมื่อเขียนโค้ดใหม่ตั้งแต่เริ่มต้นใน C ฉันพบว่าตัวเองเขียนโค้ดเป็นชั่วโมงหรือแม้กระทั่งวันโดยไม่เรียกใช้คอมไพเลอร์เพื่ออะไรนอกจากการตรวจสอบไวยากรณ์เป็นครั้งคราว ฉันมักจะเขียนโค้ดที่ใหญ่ขึ้นอย่างระมัดระวังและทดสอบอย่างละเอียดเฉพาะเมื่อฉันมั่นใจว่าโค้ดทำในสิ่งที่ควรทำโดยการวิเคราะห์โฟลว์ในหัวของฉัน อย่าเข้าใจฉันผิด - ฉันจะไม่เขียน 1,000 บรรทัดโดยไม่มีการทดสอบเลย (นั่นเป็นการพนัน) แต่ฉันจะเขียนรูทีนย่อยทั้งหมดและทดสอบ (และแก้ไขถ้าจำเป็น) หลังจากฉันคิดว่าฉันเสร็จแล้ว ในอีกด้านหนึ่งฉันเคยเห็นมือใหม่ส่วนใหญ่ที่รัน & ทดสอบโค้ดหลังจากทุกบรรทัดที่พวกเขาเข้ามาในบรรณาธิการและคิดว่าผู้ดีบั๊กสามารถใช้แทนความระมัดระวังและมีสติได้ ฉันคิดว่านี่เป็นสิ่งที่ทำให้ไขว้เขวมากเมื่อคุณได้เรียนรู้ไวยากรณ์ภาษา คุณคิดว่าอะไรคือความสมดุลที่เหมาะสมระหว่างสองแนวทาง แน่นอนคนแรกต้องมีประสบการณ์มากขึ้น แต่มันส่งผลกระทบต่อการผลิตในเชิงบวกหรือเชิงลบ? ข้อที่สองช่วยให้คุณเห็นข้อผิดพลาดในระดับที่ดีขึ้นหรือไม่

16 productivity  testing  coding 

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

16 testing  mvc 

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

15 unit-testing  testing  type-systems  enum 

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

15 unit-testing  testing 

ฉันค่อนข้างใหม่สำหรับ TDD และฉันมีปัญหาในการสร้างการทดสอบครั้งแรกของฉันเมื่อมันมาก่อนรหัสการติดตั้งใด ๆ หากไม่มีกรอบในการติดตั้งโค้ดฉันมีอิสระที่จะเขียนการทดสอบครั้งแรกของฉันได้ แต่ฉันต้องการ แต่มันก็ดูจะเสียไปโดยวิธีการคิดแบบ Java / OO ของฉันเสมอ ตัวอย่างเช่นในGithub ConwaysGameOfLifeของฉันตัวอย่างการทดสอบครั้งแรกที่ฉันเขียน (rule1_zeroNeighbours) ฉันเริ่มต้นด้วยการสร้างวัตถุ GameOfLife ที่ยังไม่ได้ใช้งาน เรียกว่าชุดวิธีการที่ไม่มีอยู่วิธีการขั้นตอนที่ไม่มีอยู่วิธีรับที่ไม่มีอยู่แล้วใช้การยืนยัน การทดสอบพัฒนาขึ้นเมื่อฉันเขียนการทดสอบและปรับโครงสร้างใหม่ แต่เดิมแล้วมันมีลักษณะดังนี้: @Test public void rule1_zeroNeighbours() { GameOfLife gameOfLife = new GameOfLife(); gameOfLife.set(1, 1, true); gameOfLife.step(); assertEquals(false, gameOfLife.get(1, 1)); } สิ่งนี้รู้สึกแปลก ๆ เนื่องจากฉันถูกบังคับให้ออกแบบการนำไปใช้ตามวิธีที่ฉันตัดสินใจในช่วงแรกนี้เพื่อเขียนการทดสอบครั้งแรก ในวิธีที่คุณเข้าใจ TDD มันโอเคไหม? ฉันดูเหมือนจะปฏิบัติตามหลักการ TDD / XP ในการทดสอบและการใช้งานของฉันที่พัฒนาตลอดเวลาด้วยการปรับโครงสร้างใหม่และดังนั้นหากการออกแบบเริ่มต้นนี้ได้พิสูจน์แล้วว่าไร้ประโยชน์มันจะเปิดให้มีการเปลี่ยนแปลง แต่รู้สึกว่าฉันกำลังบังคับทิศทาง …

15 java  testing  tdd  extreme-programming 

ฉันกำลังปรับโครงสร้างคลาสรหัสเดิมอีกครั้ง Refactoring (ฉันเข้าใจ) สนับสนุนสิ่งนี้: เขียนแบบทดสอบสำหรับคลาสดั้งเดิม refactor heck ออกจากชั้นเรียน ปัญหา: เมื่อฉันปรับโครงสร้างห้องเรียนใหม่การทดสอบของฉันในขั้นตอนที่ 1 จะต้องมีการเปลี่ยนแปลง ตัวอย่างเช่นสิ่งที่ครั้งหนึ่งเคยเป็นวิธีดั้งเดิมตอนนี้อาจเป็นชั้นแยกต่างหาก อะไรคือวิธีการหนึ่งที่อาจมีหลายวิธี ภูมิทัศน์ทั้งหมดของชั้นเรียนดั้งเดิมอาจถูกลบล้างเป็นสิ่งใหม่ดังนั้นการทดสอบที่ฉันเขียนในขั้นตอนที่ 1 เกือบจะเป็นโมฆะ ในสาระสำคัญฉันจะเพิ่มขั้นตอนที่ 3 เขียนการทดสอบของฉันอย่างล้นเหลือ อะไรคือจุดประสงค์ในการเขียนแบบทดสอบก่อนที่จะสร้างใหม่? ฟังดูคล้ายกับแบบฝึกหัดทางวิชาการในการสร้างงานให้ตัวเองมากขึ้น ฉันกำลังเขียนแบบทดสอบสำหรับวิธีนี้และฉันกำลังเรียนรู้เพิ่มเติมเกี่ยวกับวิธีทดสอบสิ่งต่าง ๆ และวิธีการทำงานแบบเดิม เราสามารถเรียนรู้สิ่งนี้ได้โดยการอ่านรหัสดั้งเดิม แต่การทดสอบการเขียนนั้นคล้ายกับการถูจมูกของฉันและการบันทึกความรู้ชั่วคราวนี้ในการทดสอบแยกต่างหาก ด้วยวิธีนี้ฉันแทบจะไม่มีทางเลือกนอกจากเรียนรู้ว่าโค้ดทำอะไร ฉันพูดว่าชั่วคราวที่นี่เพราะฉันจะ refactor heck ออกจากรหัสและเอกสารและการทดสอบทั้งหมดของฉันจะเป็นโมฆะและเป็นโมฆะเป็นส่วนสำคัญยกเว้นความรู้ของฉันจะอยู่และอนุญาตให้ฉันสดใน refactoring นั่นคือเหตุผลที่แท้จริงในการเขียนการทดสอบก่อน refactor - เพื่อช่วยให้ฉันเข้าใจรหัสได้ดีขึ้น? จะต้องมีเหตุผลอื่น! กรุณาอธิบาย! บันทึก: มีโพสต์นี้: มันทำให้รู้สึกถึงการเขียนการทดสอบสำหรับรหัสดั้งเดิมเมื่อไม่มีเวลาสำหรับการปรับโครงสร้างที่สมบูรณ์? แต่มันบอกว่า "เขียนการทดสอบก่อน refactor" แต่ไม่ได้พูดว่า "ทำไม" หรือจะทำอย่างไรถ้า "การทดสอบการเขียน" ดูเหมือนว่า …

15 testing  refactoring  tdd  legacy-code 

สิ่งที่เกี่ยวกับการยืนยันการทำงานในการทดสอบเชิงบวกพิสูจน์ว่ามันทำงาน - ฉันควรจะพูดว่ามันเสียเวลา? แนวคิดแบบไหนที่อยู่เบื้องหลังคำพูดนี้? การทดสอบที่ไม่สำเร็จเช่นการทดสอบที่ไม่พบข้อผิดพลาดนั้นเป็นการเสียเวลา วิศวกรรมเว็บ: วินัยของการพัฒนาระบบการใช้งานเว็บ quoting เซมคเนอร์

15 testing  theory 

ฉันทำงานในระบบเดิม (โดยที่ฉันหมายถึงมันเขียนโดยไม่มีการทดสอบ) เราได้ลองทดสอบระบบบางส่วนโดยการเขียนการทดสอบการรวมที่ทดสอบการทำงานจากภายนอก สิ่งนี้ทำให้ฉันมั่นใจในการ 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 

ตัวอย่างเช่นหากรหัสสร้าง int แบบสุ่มจาก 0-10 และรับสาขาที่แตกต่างกันในแต่ละผลลัพธ์หนึ่งจะออกแบบชุดทดสอบเพื่อรับประกันความครอบคลุมคำสั่ง 100% ในรหัสดังกล่าวได้อย่างไร ใน Java โค้ดอาจมีลักษณะดังนี้: int i = new Random().nextInt(10); switch(i) { //11 case statements }

15 testing  test-coverage 

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

15 testing  unit-testing 

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

15 testing  algorithms  tdd  artificial-intelligence 

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

15 testing  tdd  anti-patterns  object-oriented-design  mocking