“ to กุด” หมายถึงอะไรในการเขียนโปรแกรม?

ตัวอย่างเช่นในคำพูดนี้หมายความว่าอย่างไร

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

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

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

ตัวอย่างในโค้ดด้านล่าง:

public void Analyze(string filename)
    {
        if(filename.Length<8)
        {
            try
            {
                errorService.LogError("long file entered named:" + filename);
            }
            catch (Exception e)
            {
                mailService.SendEMail("admin@hotmail.com", "ErrorOnWebService", "someerror");
            }
        }
    }

คุณต้องการทดสอบเมธอด mailService.SendEMail ()แต่ในการทำนั้นคุณต้องจำลองExceptionในวิธีการทดสอบของคุณดังนั้นคุณต้องสร้างวัตถุFake Stub errorServiceเพื่อจำลองผลลัพธ์ที่คุณต้องการจากนั้นรหัสทดสอบของคุณจะเป็น สามารถทดสอบเมธอด mailService.SendEMail ()ได้ อย่างที่คุณเห็นคุณต้องจำลองผลลัพธ์ซึ่งมาจาก Dependency อื่นซึ่งเป็นอ็อบเจ็กต์คลาสErrorService (อ็อบเจ็กต์ Dependency ที่มีอยู่)

ต้นขั้วในบริบทนี้หมายถึงการดำเนินการเยาะเย้ย

นั่นคือการนำไปใช้งานปลอมที่เรียบง่ายซึ่งสอดคล้องกับอินเทอร์เฟซและจะใช้สำหรับการทดสอบ

เงื่อนไขของคนธรรมดาคือข้อมูลจำลอง (หรือข้อมูลปลอมข้อมูลทดสอบ ... ฯลฯ ) ที่คุณสามารถใช้ทดสอบหรือพัฒนาโค้ดของคุณได้จนกว่าคุณ (หรืออีกฝ่าย) พร้อมที่จะนำเสนอ / รับข้อมูลจริง มันคือ "Lorem Ipsum" ของโปรแกรมเมอร์

ฐานข้อมูลพนักงานไม่พร้อม? แต่งหน้าง่ายๆด้วย Jane Doe, John Doe ... ฯลฯ API ไม่พร้อม? สร้างไฟล์ปลอมโดยสร้างไฟล์. json แบบคงที่ที่มีข้อมูลปลอม

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

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

การเยาะเย้ยเป็นชนิดของต้นขั้วที่เฉพาะเจาะจงและมีข้อ จำกัด เนื่องจากการจำลองเป็นการแทนที่ฟังก์ชันหรือวัตถุอื่นสำหรับการทดสอบ ในทางปฏิบัติเรามักใช้ mocks เป็นโปรแกรมเฉพาะที่ (ฟังก์ชันหรือวัตถุ) เพื่อแทนที่โปรแกรมระยะไกลในสภาพแวดล้อมการทดสอบ ไม่ว่าในกรณีใดการจำลองอาจจำลองพฤติกรรมจริงของโปรแกรมที่ถูกแทนที่ในบริบทที่ จำกัด

ส่วนที่มีชื่อเสียงส่วนใหญ่เห็นได้ชัดสำหรับการเขียนโปรแกรมแบบกระจายเมื่อจำเป็นต้องเรียกใช้โพรซีเดอร์ระยะไกล ( RPC ) หรือวัตถุระยะไกล ( RMI , CORBA ) เฟรมเวิร์กการเขียนโปรแกรม / ไลบรารีแบบกระจายส่วนใหญ่ทำให้การสร้างต้นขั้วโดยอัตโนมัติเพื่อที่คุณจะได้ไม่ต้องเขียนด้วยตนเอง Stubs สามารถสร้างได้จากนิยามอินเตอร์เฟสซึ่งเขียนด้วยIDLเป็นต้น (แต่คุณยังสามารถใช้ภาษาใดก็ได้เพื่อกำหนดอินเทอร์เฟซ)

โดยปกติแล้วใน RPC, RMI, CORBA และอื่น ๆ สิ่งหนึ่งจะแยกความแตกต่างของต้นขั้วฝั่งไคลเอ็นต์ซึ่งส่วนใหญ่จะดูแลการจัดเรียง / ทำให้เป็นอนุกรมของอาร์กิวเมนต์และดำเนินการเรียกใช้จากระยะไกลและสตับฝั่งเซิร์ฟเวอร์ซึ่งส่วนใหญ่จะดูแลเรื่องการยกเลิกการแยกส่วน / deserializing อาร์กิวเมนต์และเรียกใช้ฟังก์ชัน / วิธีการระยะไกล เห็นได้ชัดว่าต้นขั้วไคลเอ็นต์จะอยู่ที่ฝั่งไคลเอ็นต์ในขณะที่ตัดต้นขั้ว (มักเรียกว่าโครงกระดูก) อยู่ที่ฝั่งเซิร์ฟเวอร์

การเขียนต้นขั้วที่มีประสิทธิภาพดีและทั่วไปจะค่อนข้างท้าทายเมื่อต้องจัดการกับการอ้างอิงวัตถุ เฟรมเวิร์กอ็อบเจ็กต์แบบกระจายส่วนใหญ่เช่น RMI และ CORBA จัดการกับการอ้างอิงอ็อบเจ็กต์แบบกระจาย แต่นั่นเป็นสิ่งที่โปรแกรมเมอร์ส่วนใหญ่หลีกเลี่ยงในสภาพแวดล้อม REST เช่น โดยปกติแล้วในสภาพแวดล้อม REST โปรแกรมเมอร์ JavaScript จะสร้างฟังก์ชันที่เรียบง่ายเพื่อห่อหุ้มการเรียกใช้ AJAX (การจัดลำดับวัตถุที่รองรับJSON.parseและJSON.stringify) โครงการSwagger Codegenให้การสนับสนุนอย่างกว้างขวางสำหรับการสร้าง REST Stubs โดยอัตโนมัติในภาษาต่างๆ

Stub คือนิยามฟังก์ชันที่มีชื่อฟังก์ชันที่ถูกต้องจำนวนพารามิเตอร์ที่ถูกต้องและสร้างผลลัพธ์จำลองของประเภทที่ถูกต้อง

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

คุณยังมีกรอบการทดสอบที่ดีมากในการสร้างต้นขั้ว หนึ่งในสิ่งที่ฉันชอบคือMockitoนอกจากนี้ยังมีEasyMockและอื่น ๆ ... แต่ Mockito นั้นยอดเยี่ยมมากที่คุณควรอ่าน - แพ็คเกจที่หรูหราและมีประสิทธิภาพ

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

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

RPC Stubs

• โดยทั่วไปต้นขั้วฝั่งไคลเอ็นต์เป็นโพรซีเดอร์ที่มองไปยังไคลเอนต์ราวกับว่าเป็นโพรซีเดอร์เซิร์ฟเวอร์ที่เรียกได้
• ต้นขั้วฝั่งเซิร์ฟเวอร์มองไปที่เซิร์ฟเวอร์ราวกับว่าเป็นไคลเอนต์ที่โทร
• โปรแกรมไคลเอ็นต์คิดว่ากำลังเรียกเซิร์ฟเวอร์ ในความเป็นจริงมันเรียกไคลเอนต์สตับ
• โปรแกรมเซิร์ฟเวอร์คิดว่าไคลเอนต์เรียก; ในความเป็นจริงมันถูกเรียกโดยต้นขั้วเซิร์ฟเวอร์
• ต้นขั้วส่งข้อความถึงกันเพื่อให้ RPC เกิดขึ้น

แหล่ง

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

จาก: SAMS สอนตัวเอง C ++, Jesse Liberty และ Bradley Jones