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

ฉันได้อ่านสิ่งต่าง ๆ มากมายเกี่ยวกับ TDD แต่ฉันยังมีข้อสงสัย ตัวอย่างเช่นฉันมีไดอะแกรมคลาสเหล่านี้: มันเป็นตัวอย่างง่ายๆเพียงเพื่อเรียนรู้เกี่ยวกับ TDD และวัตถุจำลอง ฉันควรเขียนแบบทดสอบใดก่อน ผลิตภัณฑ์จากนั้นLineและสุดท้ายสั่งซื้อ ? ถ้าฉันทำเช่นนั้นฉันควรใช้LineและProductเพื่อทดสอบคำสั่งซื้อหรือฉันควรใช้ Mock Objects? เมื่อใดที่ฉันควรใช้ Mock Objects ฉันควรใช้ UML กับ XP และ TDD หรือไม่ ฉันยังไม่ได้รับสิ่งเหล่านี้

14 php  unit-testing  tdd  mocking 

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

14 testing  unit-testing  tdd  integration-tests  mocking 

ฉันกำลังดิ้นรนกับการทดสอบวิธีการอัปโหลดเอกสารไปยัง Amazon S3 แต่ฉันคิดว่าคำถามนี้ใช้กับ API / การพึ่งพาภายนอกที่ไม่สำคัญใด ๆ ฉันเพิ่งได้วิธีแก้ปัญหาที่อาจเกิดขึ้นสามข้อ แต่ก็ไม่น่าพอใจ: ทำการเรียกใช้รหัสอัปโหลดเอกสารตรวจสอบกับ API ของ AWS ว่ามีการอัปโหลดแล้วและลบออกเมื่อสิ้นสุดการทดสอบ สิ่งนี้จะทำให้การทดสอบช้ามากจะเสียค่าใช้จ่ายทุกครั้งที่ทำการทดสอบและจะไม่ส่งคืนผลลัพธ์เดียวกัน จำลอง S3 มันมีขนดกมากเพราะฉันไม่รู้ว่าภายในของวัตถุนั้นและรู้สึกผิดเพราะมันซับซ้อนเกินไป เพียงตรวจสอบให้แน่ใจว่า MyObject.upload () ถูกเรียกด้วยอาร์กิวเมนต์ที่ถูกต้องและมั่นใจว่าฉันใช้วัตถุ S3 อย่างถูกต้อง ทำให้ฉันรำคาญใจเพราะไม่มีทางรู้แน่ว่าฉันใช้ S3 API อย่างถูกต้องจากการทดสอบเพียงอย่างเดียว ฉันตรวจสอบว่า Amazon ทดสอบ SDK ของตัวเองอย่างไรและพวกเขาทำทุกอย่างเยาะเย้ย พวกเขามีผู้ช่วย 200 สายที่ทำหน้าที่เยาะเย้ย ฉันไม่รู้สึกว่ามันเป็นเรื่องจริงสำหรับฉันที่จะทำเช่นเดียวกัน ฉันจะแก้ปัญหานี้ได้อย่างไร

13 testing  mocking 

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

13 unit-testing  solid  mocking  open-close  stub 

เมื่อเขียนการทดสอบทำไมบางคนต้องการใช้ฐานข้อมูลในหน่วยความจำมากกว่าเพียงการล้อเลียนข้อมูล ฉันเห็นว่าฐานข้อมูลในหน่วยความจำอาจมีประโยชน์สำหรับการทดสอบคลังเก็บของ แต่ถ้าใช้เฟรมเวิร์ก (เช่น Spring Data) การทดสอบที่เก็บจะเป็นการทดสอบเฟรมเวิร์กไม่ใช่ตรรกะแอปพลิเคชัน อย่างไรก็ตามการเยาะเย้ยดูเหมือนจะเร็วและเป็นไปตามรูปแบบเดียวกันกับที่ใช้โดยทั่วไปเมื่อเขียนการทดสอบหน่วยและ TDD แล้วฉันจะพลาดอะไรไป? ฐานข้อมูลในหน่วยความจำจะมีประโยชน์เมื่อใด / ทำไม?

12 unit-testing  testing  tdd  mocking 

ฉันกำลังทำงานกับแอพพลิเคชั่นที่มีหลายเลเยอร์ ชั้นการเข้าถึงข้อมูลเพื่อดึงและบันทึกข้อมูลจากแหล่งข้อมูลตรรกะทางธุรกิจเพื่อจัดการข้อมูลส่วนติดต่อผู้ใช้เพื่อแสดงข้อมูลบนหน้าจอ ฉันยังทำการทดสอบหน่วยของชั้นตรรกะทางธุรกิจด้วย ข้อกำหนดเพียงอย่างเดียวคือการทดสอบการไหลของตรรกะเลเยอร์ธุรกิจ ดังนั้นฉันจึงใช้ Moq framework เพื่อจำลองชั้นการเข้าถึงข้อมูลและหน่วยทดสอบชั้นตรรกะทางธุรกิจด้วยหน่วย MS ฉันใช้การเขียนโปรแกรมอินเทอร์เฟซเพื่อทำให้การออกแบบลดลงมากที่สุดเพื่อให้การทดสอบหน่วยสามารถทำได้ ชั้นการเข้าถึงข้อมูลชั้นธุรกิจโทรผ่านส่วนต่อประสาน ฉันกำลังประสบปัญหาเมื่อฉันพยายามทดสอบหนึ่งในวิธีการตรรกะทางธุรกิจ วิธีการนั้นจะทำงานและสร้างวัตถุและส่งต่อไปยัง data access layer เมื่อฉันพยายามที่จะเยาะเย้ยวิธีการเข้าถึงข้อมูลเลเยอร์แล้วก็ไม่สามารถจำลองได้สำเร็จ ที่นี่ฉันพยายามสร้างรหัสตัวอย่างเพื่อแสดงปัญหาของฉัน รุ่น: public class Employee { public string Name { get; set; } } ชั้นการเข้าถึงข้อมูล: public interface IDal { string GetMessage(Employee emp); } public class Dal : IDal { public string GetMessage(Employee emp) …

11 unit-testing  mocking 

ฉันเพิ่งอ่านข้อความที่ตัดตอนมาจากหนังสือ "Growing Object-Oriented Software" ซึ่งอธิบายเหตุผลบางอย่างว่าทำไมไม่แนะนำให้ใช้การล้อเลียนระดับคอนกรีต นี่คือตัวอย่างโค้ดของการทดสอบหน่วยสำหรับคลาส MusicCentre: public class MusicCentreTest { @Test public void startsCdPlayerAtTimeRequested() { final MutableTime scheduledTime = new MutableTime(); CdPlayer player = new CdPlayer() { @Override public void scheduleToStartAt(Time startTime) { scheduledTime.set(startTime); } } MusicCentre centre = new MusicCentre(player); centre.startMediaAt(LATER); assertEquals(LATER, scheduledTime.get()); } } และคำอธิบายแรกของเขา: ปัญหาด้วยวิธีนี้คือมันทิ้งความสัมพันธ์ระหว่างวัตถุโดยนัย ฉันหวังว่าเราได้ทำให้ชัดเจนแล้วในตอนนี้ความตั้งใจของการพัฒนาขับเคลื่อนทดสอบกับวัตถุจำลองคือการค้นพบความสัมพันธ์ระหว่างวัตถุ …

11 java  object-oriented  unit-testing  mocking  junit 

ฉันชื่อคำถามล้อเล่นเพราะฉันแน่ใจว่า "มันขึ้นอยู่กับ" แต่ฉันมีคำถามเฉพาะบางอย่าง การทำงานในซอฟต์แวร์ที่มีการพึ่งพาในระดับลึกมาก ๆ ทีมของฉันคุ้นเคยกับการใช้การเยาะเย้ยอย่างกว้างขวางเพื่อแยกโมดูลรหัสแต่ละรายการออกจากการพึ่งพาที่อยู่ด้านล่าง ดังนั้นฉันจึงประหลาดใจที่Roy Osheroveแนะนำในวิดีโอนี้ว่าคุณควรใช้การเยาะเย้ยเพียงบางอย่างเช่น 5% ของเวลา ฉันเดาว่าเรานั่งอยู่ระหว่าง 70-90% ฉันเคยเห็นคำแนะนำที่คล้ายกันเป็นครั้งคราวเช่นกัน ฉันควรกำหนดสิ่งที่ฉันพิจารณาว่าเป็นสองหมวดหมู่ของ "การทดสอบการรวม" ซึ่งแตกต่างกันอย่างมากว่าพวกเขาควรได้รับชื่อต่างกัน: 1) การทดสอบระหว่างกระบวนการซึ่งรวมโมดูลรหัสหลายโมดูลและ 2) การทดสอบนอกกระบวนการ ไปยังฐานข้อมูลระบบไฟล์บริการบนเว็บ ฯลฯ มันเป็นประเภทที่ 1 ที่ฉันกังวลการทดสอบที่รวมโมดูลรหัสหลายโมดูลทั้งหมดในกระบวนการ คำแนะนำของชุมชนส่วนใหญ่ที่ฉันได้อ่านแสดงให้เห็นว่าคุณควรเลือกการทดสอบแบบแยกหน่วยที่ละเอียดและละเอียดจำนวนมากและการทดสอบแบบรวมตั้งแต่ต้นจนจบแบบหยาบจำนวนเล็กน้อยเนื่องจากการทดสอบหน่วยจะให้ข้อเสนอแนะที่แม่นยำกับคุณ อาจมีการสร้างการถดถอย แต่การทดสอบแบบหยาบซึ่งยุ่งยากในการตั้งค่าจริงตรวจสอบการทำงานแบบ end-to-end ของระบบ ได้รับสิ่งนี้ดูเหมือนว่าจำเป็นที่จะต้องใช้การเยาะเย้ยบ่อยครั้งเพื่อแยกรหัสหน่วยแยกเหล่านี้ รับโมเดลวัตถุดังนี้: ... ยังพิจารณาด้วยว่าความลึกของการพึ่งพาแอปพลิเคชันของเรานั้นลึกกว่าที่ฉันจะได้พอดีในภาพนี้เพื่อให้มีหลายเลเยอร์ N ระหว่าง 2-4 เลเยอร์และ 5-13 เลเยอร์ ถ้าฉันต้องการทดสอบการตัดสินใจเชิงตรรกะอย่างง่าย ๆ ในหน่วย # 1 และถ้าการอ้างอิงทุกครั้งถูกสร้างขึ้นในคอนสตรัคเตอร์โค้ดที่ขึ้นอยู่กับมันเช่นนั้นพูด 2 2 3 และ …

10 unit-testing  mocking 

ปัญหาเกิดขึ้นขณะทำ TDD หลังจากผ่านการทดสอบสองสามครั้งประเภทการคืนค่าของบางคลาส / โมดูลจะเปลี่ยนไป ในภาษาการเขียนโปรแกรมแบบสแตติกถ้าวัตถุที่เยาะเย้ยก่อนหน้านี้ถูกนำมาใช้ในการทดสอบของคลาสอื่น ๆและไม่ได้รับการแก้ไขเพื่อให้สะท้อนถึงการเปลี่ยนแปลงประเภทแล้วข้อผิดพลาดในการรวบรวมจะเกิดขึ้น อย่างไรก็ตามสำหรับภาษาแบบไดนามิกการเปลี่ยนแปลงประเภทการส่งคืนอาจไม่ถูกตรวจพบและการทดสอบของคลาสอื่นจะยังคงผ่าน แน่ใจว่าอาจมีการทดสอบการรวมที่จะล้มเหลวในภายหลัง แต่การทดสอบหน่วยจะผ่านอย่างผิดพลาด มีวิธีใดบ้างที่จะหลีกเลี่ยงปัญหานี้? การอัปเดตด้วยตัวอย่างเล็ก ๆ น้อย ๆ (ในบางภาษาที่สร้างขึ้น) ... รุ่น 1: Calc = { doMultiply(x, y) {return x * y} } //.... more code .... // On some faraway remote code on a different file Rect = { computeArea(l, w) {return Calc.doMultipy(x*y)} …

10 unit-testing  mocking  tdd 

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

10 tdd  coupling  mocking 

จากการสัมภาษณ์กับ Kent Beck ในนิตยสาร Java Magazine ฉบับล่าสุด: Binstock: มาพูดคุยเรื่องไมโครไซต์ สำหรับฉันดูเหมือนว่าการทดสอบครั้งแรกเกี่ยวกับบริการไมโครซอฟท์จะซับซ้อนในแง่ที่ว่าบริการบางอย่างเพื่อให้สามารถทำงานได้จะต้องมีบริการอื่น ๆ ทั้งหมด คุณเห็นด้วยหรือไม่? เบ็ค: ดูเหมือนว่าชุดการค้าขายเดียวกันกับการมีชั้นเรียนใหญ่ ๆ Binstock: ใช่ฉันเดาว่าที่นี่คุณต้องใช้ mocks จำนวนมากเพื่อให้สามารถตั้งค่าระบบที่คุณสามารถทดสอบบริการที่กำหนดได้ เบ็ค: ฉันไม่เห็นด้วย หากอยู่ในรูปแบบที่จำเป็นคุณต้องใช้ mocks มาก ในรูปแบบการใช้งานที่มีการรวบรวมการพึ่งพาจากภายนอกเข้าด้วยกันในระดับสูงขึ้นในห่วงโซ่การโทรฉันไม่คิดว่ามันจำเป็น ฉันคิดว่าคุณสามารถได้รับความครอบคลุมมากจากการทดสอบหน่วย เขาหมายถึงอะไร สไตล์การทำงานจะช่วยปลดปล่อยคุณจากการล้อเลียนการพึ่งพาจากภายนอกได้อย่างไร?

10 functional-programming  tdd  mocking 

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

9 java  c#  programming-languages  tdd  mocking