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

พิจารณาฟังก์ชั่นเช่นนี้: function savePeople(dataStore, people) { people.forEach(person => dataStore.savePerson(person)); } มันอาจจะใช้แบบนี้: myDataStore = new Store('some connection string', 'password'); myPeople = ['Joe', 'Maggie', 'John']; savePeople(myDataStore, myPeople); ให้เราสมมติว่าStoreมีการทดสอบหน่วยของตนเองหรือได้รับการจัดหาจากผู้ขาย ในกรณีใด ๆ Storeเราไว้วางใจ และให้เราต่อไปคิดว่าจัดการข้อผิดพลาด - เช่นข้อผิดพลาดการเชื่อมต่อฐานข้อมูล - savePeopleไม่ได้เป็นความรับผิดชอบของ ที่จริงให้เราสมมติว่าตัวร้านนั้นเป็นฐานข้อมูลเวทมนต์ที่ไม่สามารถผิดพลาดได้ แต่อย่างใด ด้วยสมมติฐานเหล่านี้คำถามคือ: ควรsavePeople()ทดสอบหน่วยหรือจำนวนการทดสอบดังกล่าวเพื่อทดสอบการสร้างforEachภาษาในตัว? แน่นอนเราสามารถผ่านการเยาะเย้ยdataStoreและยืนยันที่dataStore.savePerson()เรียกว่าครั้งเดียวสำหรับแต่ละคน แน่นอนคุณสามารถโต้แย้งว่าการทดสอบดังกล่าวมีความปลอดภัยต่อการเปลี่ยนแปลงการใช้งานเช่นหากเราตัดสินใจแทนที่forEachด้วยการforวนซ้ำดั้งเดิมหรือวิธีการทำซ้ำอื่น ๆ ดังนั้นการทดสอบไม่ได้อย่างสิ้นเชิงจิ๊บจ๊อย และยังดูเหมือนว่าใกล้มาก ... นี่เป็นอีกตัวอย่างที่อาจมีผลมากกว่า พิจารณาฟังก์ชั่นที่ไม่ทำอะไรเลยนอกจากประสานงานวัตถุหรือฟังก์ชั่นอื่น ๆ ตัวอย่างเช่น: function bakeCookies(dough, pan, …

87 unit-testing  testing  tdd 

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

84 unit-testing  testing  patterns-and-practices 

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

81 testing  development-process 

ตามที่ผมเข้าใจจุดของการทดสอบหน่วยคือการทดสอบหน่วยของรหัสในการแยก หมายความว่า: พวกเขาไม่ควรทำลายโดยการเปลี่ยนแปลงรหัสที่ไม่เกี่ยวข้องใดๆ ใน codebase การทดสอบหน่วยเดียวควรทำลายข้อบกพร่องในหน่วยการทดสอบซึ่งตรงข้ามกับการทดสอบการรวม (ซึ่งอาจแบ่งเป็นฮีป) ทั้งหมดนี้แสดงถึงว่าควรมีการเยาะเย้ยจากภายนอกหน่วยทดสอบ และฉันหมายถึงการพึ่งพาภายนอกทั้งหมดไม่เพียง แต่ "เลเยอร์นอก" เช่นระบบเครือข่ายระบบไฟล์ฐานข้อมูล ฯลฯ นี้นำไปสู่ข้อสรุปเชิงตรรกะที่แทบทุกหน่วยทดสอบความต้องการที่จะเยาะเย้ย ในทางกลับกันการค้นหาอย่างรวดเร็วของ Google เกี่ยวกับการเยาะเย้ยเผยให้เห็นบทความมากมายที่อ้างว่า "การเยาะเย้ยเป็นกลิ่นรหัส" และส่วนใหญ่ควรหลีกเลี่ยง (แม้ว่าจะไม่สมบูรณ์) ตอนนี้สำหรับคำถาม การทดสอบหน่วยควรเขียนอย่างถูกต้องอย่างไร? เส้นแบ่งระหว่างพวกเขากับการทดสอบการรวมอยู่ตรงไหน? อัปเดต 1 โปรดพิจารณารหัสหลอกต่อไปนี้: class Person { constructor(calculator) {} calculate(a, b) { const sum = this.calculator.add(a, b); // do some other stuff with the `sum` } } การทดสอบที่ทดสอบPerson.calculateวิธีการโดยไม่มีการเยาะเย้ยการCalculatorพึ่งพา …

80 unit-testing  testing  integration-tests  mocking  stub 

ฉันมีการถกเถียงกับเพื่อนร่วมงานโปรแกรมเมอร์เกี่ยวกับว่ามันเป็นการปฏิบัติที่ดีหรือไม่ดีในการปรับเปลี่ยนรหัสการทำงานเพียงเพื่อให้สามารถทดสอบได้ (ผ่านการทดสอบหน่วยตัวอย่าง) ความคิดเห็นของฉันคือว่ามันใช้ได้ภายในขอบเขตของการบำรุงรักษาวัตถุที่ดีและการปฏิบัติด้านวิศวกรรมซอฟต์แวร์ที่แน่นอน (ไม่ใช่ "ทำให้ทุกอย่างเป็นสาธารณะ" ฯลฯ ) ความคิดเห็นของเพื่อนร่วมงานของฉันคือการแก้ไขรหัส (ใช้งานได้) เพื่อการทดสอบเท่านั้นผิด เป็นเพียงตัวอย่างง่ายๆลองนึกถึงโค้ดชิ้นนี้ที่ใช้โดยองค์ประกอบบางส่วน (เขียนใน C #): public void DoSomethingOnAllTypes() { var types = Assembly.GetExecutingAssembly().GetTypes(); foreach (var currentType in types) { // do something with this type (e.g: read it's attributes, process, etc). } } ฉันได้แนะนำว่ารหัสนี้สามารถแก้ไขเพื่อเรียกวิธีอื่นที่จะทำงานจริง: public void DoSomething(Assembly asm) { // not …

77 c#  programming-practices  testing  unit-testing  refactoring 

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

71 testing  web-applications  bug 

ฉันทำงานให้กับ บริษัท ผลิตภัณฑ์ซอฟต์แวร์ เรามีลูกค้าองค์กรขนาดใหญ่ที่ใช้ผลิตภัณฑ์ของเราและเราให้การสนับสนุนพวกเขา ตัวอย่างเช่นหากมีข้อบกพร่องเราให้บริการแพตช์และอื่น ๆ กล่าวคือเป็นการตั้งค่าที่ค่อนข้างทั่วไป เมื่อเร็ว ๆ นี้มีการออกตั๋วและมอบหมายให้ฉันเกี่ยวกับข้อยกเว้นที่พบโดยลูกค้าในล็อกไฟล์ซึ่งเกี่ยวข้องกับการเข้าถึงฐานข้อมูลพร้อมกันในการใช้งานกลุ่มผลิตภัณฑ์ของเรา ดังนั้นการกำหนดค่าเฉพาะของลูกค้ารายนี้อาจมีความสำคัญในการเกิดข้อผิดพลาดนี้ สิ่งที่เราได้รับจากลูกค้าคือไฟล์บันทึกของพวกเขา วิธีที่ฉันเสนอให้กับทีมของฉันคือพยายามทำซ้ำข้อผิดพลาดในการตั้งค่าการกำหนดค่าที่คล้ายกับของลูกค้าและรับบันทึกที่เปรียบเทียบกันได้ อย่างไรก็ตามพวกเขาไม่เห็นด้วยกับวิธีการของฉันบอกว่าฉันไม่จำเป็นต้องทำซ้ำข้อผิดพลาดเพราะมันใช้เวลานานเกินไปและจะต้องจำลองเซิร์ฟเวอร์คลัสเตอร์บน VMs ทีมของฉันแนะนำให้ฉันเพียง "ติดตามรหัส" เพื่อดูว่ารหัสเธรดและ / หรือธุรกรรมที่ไม่ปลอดภัยอยู่ที่ใดและเปลี่ยนการทำงานนอกการพัฒนาท้องถิ่นอย่างง่ายซึ่งไม่ใช่การใช้คลัสเตอร์เช่นสภาพแวดล้อมที่เกิดขึ้น ของข้อผิดพลาดมา สำหรับฉันแล้วการทำงานจากพิมพ์เขียวที่เป็นนามธรรม (รหัสโปรแกรม) แทนที่จะเป็นรูปธรรมที่ชัดเจนและชัดเจน (การทำสำเนารันไทม์) ดูเหมือนยากดังนั้นฉันต้องการถามคำถามทั่วไป: มันมีเหตุผลที่จะยืนยันในการทำซ้ำทุกข้อบกพร่องและแก้ปัญหาก่อนที่จะวินิจฉัยและแก้ไขหรือไม่ หรือ: ถ้าฉันเป็นนักพัฒนาอาวุโสฉันควรจะสามารถอ่านรหัสแบบมัลติเธรดและสร้างภาพจิตของสิ่งที่มันทำในทุกกรณีสถานการณ์การใช้งานมากกว่าที่จะต้องเรียกใช้แอปพลิเคชันทดสอบสถานการณ์การใช้กรณีและสถานการณ์ที่แตกต่างกัน บรรทัดรหัสโดยบรรทัด? หรือฉันเป็นผู้พัฒนาที่ไม่ดีสำหรับความต้องการสภาพแวดล้อมการทำงานแบบนั้น? การดีบักสำหรับน้องสาวหรือไม่? ในความเห็นของฉันการแก้ไขใด ๆ ที่ส่งมาเพื่อตอบสนองต่อตั๋วเหตุการณ์ควรทดสอบในสภาพแวดล้อมที่จำลองขึ้นให้ใกล้เคียงกับสภาพแวดล้อมเดิมมากที่สุด คุณจะรู้ได้อย่างไรว่ามันจะแก้ไขปัญหาได้จริง ๆ ? มันเหมือนกับการปล่อยรถรุ่นใหม่โดยไม่มีการทดสอบการชนด้วยหุ่นจำลองเพื่อแสดงให้เห็นว่าถุงลมนิรภัยใช้งานได้จริง สุดท้าย แต่ไม่ท้ายสุดถ้าคุณเห็นด้วยกับฉัน: ฉันจะพูดคุยกับทีมของฉันเพื่อโน้มน้าวพวกเขาได้อย่างไรว่าแนวทางของฉันนั้นมีความสมเหตุสมผล

70 testing  debugging  bug  technical-support  defect 

เมื่อไม่นานมานี้ฉันกำลังเขียนโค้ดขนาดเล็กซึ่งจะบ่งบอกถึงวิธีการที่เป็นมิตรกับมนุษย์ว่าเหตุการณ์มีอายุเท่าไร ตัวอย่างเช่นอาจบ่งบอกว่าเหตุการณ์เกิดขึ้น“ สามสัปดาห์ที่ผ่านมา” หรือ“ เดือนที่แล้ว” หรือ“ เมื่อวานนี้” ความต้องการค่อนข้างชัดเจนและนี่เป็นกรณีที่สมบูรณ์แบบสำหรับการพัฒนาแบบทดสอบที่ขับเคลื่อน ฉันเขียนการทดสอบทีละตัวการใช้รหัสเพื่อผ่านการทดสอบแต่ละครั้งและทุกอย่างดูเหมือนจะทำงานได้อย่างสมบูรณ์ จนกว่าจะพบข้อบกพร่องในการผลิต นี่คือโค้ดที่เกี่ยวข้อง: now = datetime.datetime.utcnow() today = now.date() if event_date.date() == today: return "Today" yesterday = today - datetime.timedelta(1) if event_date.date() == yesterday: return "Yesterday" delta = (now - event_date).days if delta < 7: return _number_to_text(delta) + " days ago" if …

67 testing  programming-logic 

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

64 testing  test-coverage 

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

62 testing  unit-testing  tdd  bdd  integration-tests 

เราพยายามออกแบบระบบของเราให้สามารถทดสอบได้และส่วนใหญ่พัฒนาโดยใช้ TDD ขณะนี้เรากำลังพยายามแก้ไขปัญหาต่อไปนี้: ในสถานที่ต่าง ๆ เราจำเป็นต้องใช้วิธีการช่วยเหลือแบบคงที่เช่น ImageIO และ URLEncoder (ทั้ง Java API มาตรฐาน) และห้องสมุดอื่น ๆ อีกมากมายที่ประกอบด้วยวิธีคงที่ส่วนใหญ่ (เช่นไลบรารี Apache Commons) แต่มันยากมากที่จะทดสอบวิธีการเหล่านั้นที่ใช้คลาสตัวช่วยแบบคงที่ ฉันมีความคิดหลายอย่างสำหรับการแก้ปัญหานี้: ใช้เฟรมเวิร์กจำลองที่สามารถจำลองคลาสแบบคงที่ (เช่น PowerMock) นี่อาจเป็นทางออกที่ง่ายที่สุด แต่ก็รู้สึกอยากยอมแพ้ สร้างคลาส wrapper ทันทีที่มีรอบยูทิลิตี้คงที่เหล่านั้นเพื่อให้พวกเขาสามารถฉีดเข้าไปในชั้นเรียนที่ใช้พวกเขา ดูเหมือนว่าจะเป็นคำตอบที่ค่อนข้างสะอาด แต่ฉันกลัวว่าเราจะจบลงด้วยการสร้างคลาส wrapper เหล่านั้น แยกการเรียกคลาสผู้ช่วยแบบคงที่เหล่านี้ลงในฟังก์ชันที่สามารถแทนที่ได้และทดสอบคลาสย่อยของคลาสที่ฉันต้องการทดสอบจริง ๆ แต่ฉันคิดอยู่เสมอว่านี่จะเป็นปัญหาที่หลายคนต้องเผชิญเมื่อทำ TDD - ดังนั้นจะต้องมีวิธีแก้ไขปัญหานี้อยู่แล้ว กลยุทธ์ที่ดีที่สุดในการรักษาคลาสที่ใช้ตัวช่วยคงที่สามารถทดสอบได้คืออะไร

62 java  testing  tdd  static-methods 

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

62 testing  bug  compiler  system-reliability 

ดังนั้นวันนี้ฉันได้พูดคุยกับเพื่อนร่วมทีมเกี่ยวกับการทดสอบหน่วย สิ่งทั้งหมดเริ่มต้นขึ้นเมื่อเขาถามฉันว่า "เฮ้การทดสอบของชั้นนั้นอยู่ที่ไหนฉันเห็นเพียงอันเดียว" ทั้งคลาสนั้นเป็นผู้จัดการ (หรือบริการถ้าคุณต้องการเรียกมันอย่างนั้น) และวิธีการเกือบทั้งหมดเป็นเพียงการมอบหมายสิ่งของให้กับ DAO ดังนั้นมันจึงคล้ายกับ: SomeClass getSomething(parameters) { return myDao.findSomethingBySomething(parameters); } ประเภทของแผ่นสำเร็จรูปที่ไม่มีตรรกะ (หรืออย่างน้อยฉันไม่ได้พิจารณาการมอบหมายอย่างง่ายเช่นตรรกะ) แต่เป็นแผ่นที่มีประโยชน์ในกรณีส่วนใหญ่ (การแยกชั้น ฯลฯ ) และเรามีการอภิปรายค่อนข้างยาวว่าควรทดสอบยูนิทหรือไม่ (ฉันคิดว่ามันคุ้มค่าที่จะกล่าวถึงว่าฉันทำการทดสอบยูนิทอย่างเต็มที่) ข้อโต้แย้งหลักของเขาคือว่าไม่ใช่ TDD (ชัดเจน) และบางคนอาจต้องการดูการทดสอบเพื่อตรวจสอบว่าวิธีการนี้ทำอะไร (ฉันไม่ทราบว่ามันจะชัดเจนมากขึ้น) หรือในอนาคตบางคนอาจต้องการเปลี่ยน การนำไปใช้งานและเพิ่มตรรกะ (หรือเช่น "ใด ๆ ") ใหม่ให้กับตรรกะนั้น (ซึ่งในกรณีนี้ฉันคิดว่าบางคนควรทดสอบตรรกะนั้น) นี่ทำให้ฉันคิดว่า เราควรมุ่งมั่นเพื่อให้ครอบคลุมการทดสอบมากที่สุดหรือไม่? หรือเป็นเพียงศิลปะเพื่อประโยชน์ของงานศิลปะในเวลานั้น? ฉันไม่เห็นเหตุผลใด ๆ ที่อยู่เบื้องหลังการทดสอบสิ่งต่าง ๆ เช่น: getters และ setters (ยกเว้นว่าพวกเขามีเหตุผลบางอย่างในตัวพวกเขา) รหัส "สำเร็จรูป" เห็นได้ชัดว่าการทดสอบวิธีการดังกล่าว …

61 testing  unit-testing  tdd 

เราเป็นทีมการต่อสู้ของนักพัฒนา 3 คนนักออกแบบ 1 คนต้นแบบการต่อสู้และเจ้าของผลิตภัณฑ์ อย่างไรก็ตามเราไม่มีผู้ทดสอบอย่างเป็นทางการในทีมของเรา ปัญหาที่เกิดขึ้นกับเราเสมอคือการทดสอบแอปพลิเคชันและผ่านการทดสอบและการลบข้อบกพร่องนั้นได้ถูกกำหนดเป็นหนึ่งในเกณฑ์ในการพิจารณา PBI (Product Backlog Item) เช่นเดียวกับที่ทำ แต่ปัญหาคือว่าไม่ว่าเรา (นักพัฒนา 3 คนและนักออกแบบ 1 คน) จะพยายามทดสอบแอปพลิเคชันและใช้งานกรณียังคงมีข้อบกพร่องบางอย่างที่ไม่เห็นและทำลายการนำเสนอของเรา ( กฎหมายของเมอร์ฟี่ ) เพื่อเป็นการแก้ไขเราแนะนำให้ บริษัท ว่าจ้างผู้ทดสอบรายใหม่ ใครบางคนที่ทำหน้าที่ทดสอบและทดสอบเท่านั้น ผู้ทดสอบมืออาชีพอย่างเป็นทางการ อย่างไรก็ตามปัญหาคือว่าการต่อสู้หลักและผู้มีส่วนได้เสียเชื่อว่านักพัฒนา (หรือนักออกแบบ) ควรเป็นผู้ทดสอบ ถูกต้องหรือไม่ เราควรพัฒนา (หรือผู้ออกแบบ) ด้วยเช่นกัน?

60 testing  scrum 

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

59 testing  refactoring