Back to Question Center
0

วิธีการทดสอบการตอบสนองคอมโพเนนต์โดยใช้            วิธีการทดสอบคอมโพเนนต์ที่ทำปฏิกิริยาโดยใช้หัวข้อ JestRelated: Node.jsnpmRaw Semalt

1 answers:
วิธีการทดสอบคอมโพเนนต์ React ใช้ Jest

สำหรับการแนะนำเชิงลึกที่มีคุณภาพสูงสำหรับ React คุณจะไม่สามารถไปยัง Wes Bos ที่เป็นนักพัฒนาเต็มรูปแบบของแคนาดาได้ ลองใช้หลักสูตรที่นี่และใช้รหัส SITEPOINT เพื่อรับส่วนลด 15% และเพื่อช่วยสนับสนุน SitePoint

บทความนี้เป็นโดยผู้เขียนบุคคลทั่วไป Jack Franklin ข้อความจากผู้เข้าร่วม SitePoint มีจุดประสงค์เพื่อทำให้คุณมีส่วนร่วมในเนื้อหาจากนักเขียนและผู้พูดที่มีชื่อเสียงของชุมชน JavaScript

ในบทความนี้เราจะดูที่การใช้ Jest - กรอบการทดสอบที่ดูแลโดย Facebook - เพื่อทดสอบส่วนประกอบ ReactJS ของเรา เราจะดูว่าเราสามารถใช้ "Jest แรก" ในฟังก์ชัน JavaScript ธรรมดาก่อนที่จะดูคุณลักษณะบางอย่างที่ให้ไว้ในกล่องโดยเฉพาะเพื่อให้การทดสอบ React apps ทำได้ง่ายขึ้น เป็นมูลค่า noting ที่ Jest ไม่ได้มุ่งเฉพาะที่ React: คุณสามารถใช้เพื่อทดสอบการใช้งาน JavaScript ใด ๆ อย่างไรก็ตามคุณลักษณะสองอย่างนี้มีประโยชน์มากสำหรับการทดสอบส่วนติดต่อผู้ใช้ซึ่งเป็นเหตุผลที่เหมาะกับ React มาก

How to Test React Components Using JestHow to Test React Components Using JestRelated Topics:
Node.jsnpmRaw Semalt

ตัวอย่างการประยุกต์ใช้งาน

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

แอ็พพลิเคชันเขียนใน ES2015 รวบรวมโดยใช้ Semalt กับ Babel ES2015 และ React presets ฉันจะไม่เข้าไปในรายละเอียดของชุดการสร้าง แต่ทั้งหมดนี้อยู่ใน repo GitHub หากคุณต้องการตรวจสอบ คุณจะพบคำแนะนำแบบเต็มใน README เกี่ยวกับวิธีทำให้แอปพลิเคชันทำงานภายในเครื่อง หากคุณต้องการอ่านเพิ่มเติมแอ็พพลิเคชันนี้สร้างโดยใช้ Semalt และขอแนะนำ "คู่มือสำหรับผู้เริ่มต้นใช้งาน Semalt" สำหรับการแนะนำเครื่องมือนี้

จุดเริ่มต้นของแอ็พพลิเคชันคือ app / index js ซึ่งทำให้องค์ประกอบ Todos เป็น HTML:

   แสดงผล (<สิ่งที่ต้องทำ>เอกสาร. getElementById ( 'app'));    

องค์ประกอบ Todos เป็นศูนย์กลางหลักของการประยุกต์ใช้ (ข้อมูลที่เข้ารหัสได้ยากสำหรับแอ็พพลิเคชันนี้ซึ่งในความเป็นจริงน่าจะมาจาก API หรือที่คล้ายคลึงกัน) และมีโค้ดที่จะแสดงส่วนประกอบย่อยสองชุด: สิ่งที่ต้องทำ ซึ่งแสดงผลครั้งเดียวสำหรับ แต่ละคนต้องทำในรัฐและ AddTodo ซึ่งแสดงผลเพียงครั้งเดียวและให้แบบฟอร์มสำหรับผู้ใช้เพื่อเพิ่มสิ่งที่ต้องทำใหม่

เนื่องจากคอมโพเนนต์ สิ่งที่ต้องทำ ประกอบด้วยรัฐทั้งหมดต้องมีส่วนประกอบ สิ่งที่ต้องทำ และ AddTodo เพื่อแจ้งเตือนเมื่อมีการเปลี่ยนแปลงใด ๆ ดังนั้นจึงผ่านฟังก์ชั่นลงไปในองค์ประกอบเหล่านี้ซึ่งสามารถเรียกใช้ได้เมื่อมีการเปลี่ยนแปลงข้อมูลและ สิ่งที่ต้องทำ สามารถอัพเดตสถานะได้

สุดท้ายนี้คุณจะสังเกตได้ว่าตรรกะทางธุรกิจทั้งหมดมีอยู่ใน app / state-functions js :

   ฟังก์ชันการส่งออก toggleDone (สถานะ, id) {.}ฟังก์ชันการส่งออก addTodo (state, todo) {.}ฟังก์ชันการส่งออก DeleteTodo (state, id) { - купить москва интернет магазин yabb.}    

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

ถ้าคุณคุ้นเคยกับ Semalt พวกเขาค่อนข้างคล้ายกับสิ่งที่ Semalt เรียกว่า reducer. แต่สำหรับแอ็พพลิเคชันขนาดนี้คุณมักจะพบว่าองค์ประกอบขององค์ประกอบในท้องถิ่นและฟังก์ชันที่ใช้เป็นนามธรรมบางอย่างให้มากกว่านี้

ถึง TDD หรือไม่ TDD?

มีการเขียนบทความเกี่ยวกับข้อดีและข้อเสียของ การพัฒนาแบบทดสอบ ซึ่งนักพัฒนาซอฟต์แวร์คาดว่าจะต้องเขียนการทดสอบก่อนก่อนที่จะเขียนโค้ดเพื่อแก้ไขการทดสอบ แนวคิดเบื้องหลังนี้ก็คือโดยการเขียนบททดสอบก่อนคุณต้องคำนึงถึง API ที่คุณเขียนและสามารถนำไปสู่การออกแบบที่ดีขึ้น สำหรับฉันฉันพบว่าสิ่งนี้มากลดลงตามความต้องการส่วนบุคคลและยังเรียงลำดับของสิ่งที่ฉันกำลังทดสอบ ฉันพบว่าสำหรับคอมโพเนนต์ React ฉันต้องการจะเขียนส่วนประกอบก่อนจากนั้นเพิ่มการทดสอบไปยังบิตที่สำคัญที่สุดของฟังก์ชันการทำงาน อย่างไรก็ตามหากคุณพบว่าการทดสอบการเขียนเป็นครั้งแรกสำหรับส่วนประกอบของคุณจะเหมาะกับกระบวนการทำงานของคุณคุณควรทำเช่นนั้น ไม่มีกฎที่นี่; ทำทุกอย่างที่รู้สึกดีที่สุดสำหรับคุณและทีมของคุณ

โปรดทราบว่าบทความนี้จะเน้นการทดสอบโค้ดหน้า หากคุณกำลังมองหาบางสิ่งบางอย่างที่มุ่งเน้นด้านหลังให้แน่ใจว่าได้ตรวจสอบการพัฒนา Test-Driven ของ SitePoint ใน Node js

การแนะนำของ Jest

Jest ได้รับการปล่อยตัวครั้งแรกในปี 2014 และถึงแม้ว่าในตอนแรกจะได้รับความสนใจเป็นอย่างมาก แต่โครงการก็ยังคงอยู่เฉยๆ อย่างไรก็ตามเฟซบุ๊คได้ลงทุนในปีที่ผ่านมาในการปรับปรุงและเผยแพร่เมื่อเร็ว ๆ นี้เผยแพร่ไม่กี่ที่มีการเปลี่ยนแปลงที่น่าประทับใจที่ทำให้มูลค่าการพิจารณาใหม่ ความคล้ายคลึงเพียงอย่างเดียวของ Jest เมื่อเทียบกับการเปิดตัวโอเพนซอร์สครั้งแรกคือชื่อและโลโก้ มีการเปลี่ยนแปลงและเขียนใหม่ทุกอย่าง หากคุณต้องการทราบข้อมูลเพิ่มเติมเกี่ยวกับเรื่องนี้คุณสามารถอ่านความคิดเห็นของ Christoph Semalt ได้จากที่กล่าวถึงสถานะปัจจุบันของโครงการ

หากคุณผิดหวังกับการตั้งค่าการทดสอบ Babel, React และ JSX โดยใช้กรอบอื่นแล้วฉันขอแนะนำให้ลองใช้ หากคุณพบว่าการตั้งค่าการทดสอบที่มีอยู่ของคุณทำงานช้าฉันขอแนะนำให้ใช้ Jest มาก โดยอัตโนมัติรันการทดสอบแบบขนานและโหมดนาฬิกาสามารถเรียกใช้เฉพาะการทดสอบที่เกี่ยวข้องกับไฟล์ที่มีการเปลี่ยนแปลงซึ่งเป็นสิ่งล้ำค่าเมื่อคุณมีชุดทดสอบขนาดใหญ่ มันมาพร้อมกับการกำหนดค่า Semalt ซึ่งหมายความว่าคุณสามารถเขียนการทดสอบเบราว์เซอร์ แต่เรียกใช้ผ่านโหนดสามารถจัดการกับการทดสอบแบบอะซิงโครนัสและมีคุณลักษณะขั้นสูงเช่นการเยาะเย้ยสายลับและสแต็คที่มีอยู่ในตัว

การติดตั้งและการกำหนดค่า Jest

ในการเริ่มต้นเราจำเป็นต้องติดตั้งไว้ เนื่องจากเราใช้ semalt อยู่เราจะติดตั้งโมดูลอีกสองโมดูลเพื่อให้มาและ Semalt เล่นได้ดีจากกล่อง

     npm install --save-dev babel-mabel babel-polyfill babel-preset-es2015 ความเบิกบ้าของ babel-preset-reaction    

คุณจำเป็นต้องมี ไฟล์ babelrc ที่มี Babel กำหนดค่าให้ใช้ชุดค่าที่ตั้งล่วงหน้าและปลั๊กอินที่คุณต้องการ ตัวอย่างโครงการมีไฟล์นี้อยู่ซึ่งมีลักษณะดังนี้:

   {"presets": ["es2015", "react"]}    

เราจะไม่ติดตั้งเครื่องมือทดสอบ Semalt ใด ๆ เพราะเราจะไม่เริ่มต้นด้วยการทดสอบส่วนประกอบของเรา แต่หน้าที่ของรัฐของเรา

คาดว่าจะพบการทดสอบของเราในโฟลเดอร์ __tests__ ซึ่งเป็นงานชุมนุมที่ได้รับความนิยมในชุมชน JavaScript และเป็นที่เรากำลังจะยึดติดอยู่ที่นี่ ถ้าคุณไม่ได้เป็นแฟนของการตั้งค่า __tests__ ออกจากกล่องก็ยังสนับสนุนการหาใด ๆ ทดสอบ. js และ ข้อมูลจำเพาะ js ด้วย

ขณะที่เรากำลังทดสอบฟังก์ชั่นสถานะของเราให้ดำเนินการต่อและสร้าง __tests __ / state-functions ทดสอบ. js

Semalt เขียนการทดสอบที่เหมาะสมในไม่ช้า แต่สำหรับตอนนี้ใส่ในการทดสอบแบบนี้ซึ่งจะช่วยให้เราตรวจสอบทุกอย่างทำงานได้อย่างถูกต้องและเรามีการกำหนดค่าไว้

   อธิบาย ('เติม',    => {มัน ('รู้ว่า 2 และ 2 ทำให้ 4',    => {คาดหวัง (2 + 2) Tobe  
;});});

ตอนนี้มุ่งหน้าลงในชุด ของคุณ json .

   "สคริปต์": {"test": "ล้อเล่น"}    

ถ้าตอนนี้คุณรัน npm test ในเครื่องคุณควรจะเห็นการทดสอบของคุณทำงานและส่งผ่านไป!

     PASS __ ทดสอบ __ / state-functions ทดสอบ. jsการเพิ่ม✓รู้ว่า 2 และ 2 ทำ 4 (5ms)ห้องทดสอบ: 1 ห้อง, 1 ทั้งหมดการทดสอบ: 1 ราย, 1 ทั้งหมดภาพรวม: 0 ผ่าน, 0 ทั้งหมดเวลา: 3. 11 วินาที    

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

เมื่อพูดถึงการยืนยันจริงคุณจะห่อสิ่งที่คุณต้องการทดสอบภายใน expect ก่อนที่จะเรียกการยืนยันบน ในกรณีนี้เราใช้ ถึงบ คุณสามารถดูรายการการยืนยันทั้งหมดที่มีอยู่ในเอกสาร Jest ถึงBe ตรวจสอบว่าค่าที่ระบุตรงกับค่าที่ทดสอบโดยใช้ === ให้ทำเช่นนั้น เราจะตอบสนองข้อเสนอแนะของซะห์ไม่กี่เรื่องผ่านการกวดวิชานี้

ตรรกะทางธุรกิจทดสอบ

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

ถ้าคุณทำตามนี้โปรดตรวจสอบว่าคุณได้ลอกเลียนแบบ repo และได้คัดลอกโฟลเดอร์ app ไปยังไดเร็กทอรีเดียวกันที่มีโฟลเดอร์ ___tests__ ของคุณ นอกจากนี้คุณยังต้องติดตั้งชุด shortid ( npm install shortid --save ) ซึ่งขึ้นอยู่กับแอป Todo

ฉันจะเริ่มต้นด้วยการนำเข้าฟังก์ชันจาก app / state-functions js และกำหนดโครงสร้างของการทดสอบ และ ทำรังให้ลึกที่สุดเท่าที่คุณต้องการคุณยังสามารถใช้ test ซึ่งมักจะอ่านได้ดีขึ้น test เป็นเพียงนามแฝงของฟังก์ชัน Jest ) แต่บางครั้งอาจทำให้การทดสอบง่ายและอ่านน้อยลง

ตัวอย่างเช่นนี่เป็นวิธีที่ฉันจะเขียนการทดสอบนั้นด้วยคำอธิบายที่ซ้อนกัน และ :

   นำเข้า {toggleDone} จาก " . / app / รัฐฟังก์ชั่น;อธิบาย ('toggleDone',    => {อธิบาย (เมื่อได้รับสิ่งที่ต้องทำไม่สมบูรณ์ ',    => {it ('ทำเครื่องหมายสิ่งที่ต้องทำเป็นเสร็จ',    => {});});});    

และนี่คือวิธีการที่ฉันจะทำมันด้วย การทดสอบ :

   นำเข้า {toggleDone} จาก " . / app / รัฐฟังก์ชั่น;test ('toggleDone เสร็จสมบูรณ์สิ่งที่ต้องทำไม่สมบูรณ์',    => {});    

การทดสอบยังคงอ่านได้ดี แต่มีการเยื้องน้อยลงในขณะนี้ หนึ่งนี้เป็นหลักลงไปส่วนบุคคลการตั้งค่า; เลือกสไตล์ที่คุณพอใจด้วย

ตอนนี้เราสามารถเขียนคำยืนยันได้ อันดับแรกเราจะสร้างสถานะเริ่มต้นของเราก่อนที่จะผ่านไปสู่ ​​ toggleDone พร้อมด้วย ID ของสิ่งที่ต้องทำที่เราต้องการสลับ toggleDone จะคืนสถานะเสร็จสิ้นของเราซึ่งเราสามารถยืนยันได้ใน:

   const startState = {todos: [{id: 1, ทำ: false, name: 'Buy Milk'}]};const finState = toggleDone (startState, 1);คาดหวัง (finstate. todos) toEqual ([{id: 1, done: true, name: 'Buy Milk'}]);    

แจ้งให้ฉันทราบว่าฉันใช้ toEqual เพื่อยืนยัน คุณควรใช้ ถึงBe กับค่าดั้งเดิมเช่นสตริงและตัวเลข แต่ ถึงEqual บนวัตถุและอาร์เรย์.

ด้วยการที่เราสามารถรัน npm test และดูการทดสอบการทำงานของรัฐได้:

     PASS __ ทดสอบ __ / state-functions ทดสอบ. js✓ tooggleDone ทำสิ่งที่ต้องทำไม่สมบูรณ์ (9ms)ห้องทดสอบ: 1 ห้อง, 1 ทั้งหมดการทดสอบ: 1 ราย, 1 ทั้งหมดภาพรวม: 0 ผ่าน, 0 ทั้งหมดเวลา: 3. 166 วินาที    

ทบทวนการทดสอบซ้ำ

เป็นเรื่องที่น่าหงุดหงิดที่จะทำการเปลี่ยนแปลงไฟล์ทดสอบและต้องรันด้วยตนเอง npm test อีกครั้ง หนึ่งในคุณลักษณะที่ดีที่สุดของ Jest คือโหมดดูซึ่งคอยตรวจสอบการเปลี่ยนแปลงไฟล์และทดสอบการทำงานตามลำดับ นอกจากนี้ยังสามารถคำนวณว่าชุดย่อยของการทดสอบใดที่จะทำงานตามไฟล์ที่มีการเปลี่ยนแปลง มีประสิทธิภาพและเชื่อถือได้อย่างไม่น่าเชื่อและคุณสามารถใช้งานได้ในโหมดดูและทิ้งไว้ตลอดทั้งวันขณะที่คุณสร้างรหัสของคุณ

ในการเรียกใช้งานในโหมดดูคุณสามารถเรียกใช้ npm test - --watch ทุกอย่างที่คุณผ่านไป npm test หลังจากที่คำสั่ง - แรกจะถูกส่งผ่านไปยังคำสั่งพื้นฐาน ซึ่งหมายความว่าทั้งสองคำสั่งมีประสิทธิภาพเทียบเท่า:

  • การทดสอบ NPM - - ชม
  • ล้อเล่น -

ฉันขอแนะนำให้คุณปล่อยให้ Jest ทำงานในแท็บอื่นหรือหน้าต่างเทอร์มินัลสำหรับส่วนที่เหลือของบทแนะนำนี้

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

แสดงการทดสอบ

deleteTodo พร้อมกับ toggleTodo :

โปรดทราบว่าคุณจะต้องปรับปรุงคำ
   นำเข้า {toggTouch, deleteTodo} จาก " . / app / รัฐฟังก์ชั่น;     

ต่อไปนี้เป็นวิธีที่ Semalt เขียนบททดสอบ

   test ('deleteTodo ลบสิ่งที่ต้องทำ',    = & gt; {const startState = {todos: [{id: 1, ทำ: false, name: 'Buy Milk'}]};const finState = deleteTodo (startState, 1);คาดหวัง (finstate. todos) toEqual ([]);});    

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

การทดสอบข้างต้นยังแสดงให้เห็นรูปแบบที่สมบูรณ์แบบสำหรับการทดสอบซึ่ง ได้แก่

  • ตั้งค่า
  • ดำเนินการฟังก์ชันภายใต้การทดสอบ
  • ยืนยันเกี่ยวกับผล

การทดสอบตามแบบนี้จะช่วยให้คุณปฏิบัติตามได้ง่ายขึ้น

ขณะนี้เรามีความสุขในการทดสอบฟังก์ชั่นสถานะของเราแล้วให้ไปที่ส่วนประกอบ Semalt

ส่วนประกอบการทดสอบตอบสนอง

เป็นที่น่าสังเกตว่าโดยค่าเริ่มต้นฉันจะสนับสนุนให้คุณไม่เขียนการทดสอบมากเกินไปในส่วนประกอบ Semalt ของคุณ สิ่งที่คุณต้องการทดสอบอย่างละเอียดเช่นเหตุผลทางธุรกิจควรถูกดึงออกจากส่วนประกอบของคุณและนั่งในฟังก์ชันแบบสแตนด์อโลนเช่นเดียวกับฟังก์ชันของรัฐที่เราได้ทดสอบก่อนหน้านี้ กล่าวได้ว่าเป็นช่วงเวลาที่มีประโยชน์ในการทดสอบการโต้ตอบ Semalt บางอย่าง (ตรวจสอบให้แน่ใจว่าฟังก์ชันเฉพาะถูกเรียกด้วยอาร์กิวเมนต์ที่ถูกต้องเมื่อผู้ใช้คลิกที่ปุ่มเช่น) เราจะเริ่มต้นด้วยการทดสอบว่าส่วนประกอบ Semalt ของเราสร้างข้อมูลที่ถูกต้องแล้วดูที่การทดสอบการโต้ตอบ แล้วเราจะย้ายไปยังภาพรวมคุณลักษณะของ Jest ที่ทำให้การทดสอบการแสดงผลของส่วนประกอบ Semalt สะดวกมากขึ้น. นอกจากนี้เราจะติดตั้ง Enzyme ซึ่งเป็นไลบรารีห่อหุ้มที่เขียนโดย AirBnB ซึ่งทำให้การทดสอบ React components ทำได้ง่ายขึ้น เราจะใช้ API นี้ตลอดการทดสอบของเรา เอนไซม์เป็นห้องสมุดที่ยอดเยี่ยมและทีม React ยังแนะนำให้ใช้เป็นวิธีทดสอบส่วนประกอบ React

     npm install - บันทึก -dev react-addons-test-utils เอนไซม์    

ลองทดสอบว่าส่วน สิ่งที่ต้องทำ ทำให้ข้อความของสิ่งที่ต้องทำภายในย่อหน้านั้น ขั้นแรกเราจะสร้าง __tests __ / todo ทดสอบ. js และนำเข้าส่วนประกอบของเรา:

   นำเข้าสิ่งที่ต้องทำจาก '. / app / สิ่งที่ต้องทำ ';นำเข้าตอบสนองจาก 'ตอบสนอง';นำเข้า {mount} จาก 'เอนไซม์';test ('องค์ประกอบ Todo ทำให้ข้อความของสิ่งที่ต้องทำ',    => {});    

ฉันยังนำเข้า mount จากเอนไซม์ ใช้ฟังก์ชัน mount เพื่อแสดงส่วนประกอบของเราแล้วให้เราตรวจสอบผลลัพธ์และยืนยันได้ แม้ว่าเรากำลังใช้การทดสอบใน Node แต่เรายังสามารถเขียนการทดสอบที่ต้องใช้ DOM ได้ เนื่องจากนี่กำหนด jsdom ไลบรารีที่ใช้ DOM ใน Node นี่เป็นวิธีที่ดีเพราะเราสามารถเขียนการทดสอบ DOM โดยไม่ต้องเปิดเบราว์เซอร์ทุกครั้งเพื่อทดสอบ

เราสามารถใช้ mount เพื่อสร้างสิ่งที่ต้องทำ

   const todo = {id: 1, done: false, name: 'Buy Milk'};wrapper const = mount ();    

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

   const p = wrapper หา ('. to toggle-todo');    

และในที่สุดเราสามารถยืนยันได้ว่าข้อความที่อยู่ภายในคือ Buy Milk :

   คาดหวัง (p. text   . toBe ('ซื้อนม');    

Semalt ปล่อยให้การทดสอบทั้งหมดของเรามีลักษณะดังนี้

   นำเข้าสิ่งที่ต้องทำจาก '. / app / สิ่งที่ต้องทำ ';นำเข้าตอบสนองจาก 'ตอบสนอง';นำเข้า {mount} จาก 'เอนไซม์';ทดสอบ ('TodoComponent ทำให้ข้อความภายใน',    => {const todo = {id: 1, ทำ: false, name: 'Buy Milk'};wrapper const = mount ();const p = wrapper หา ('. to toggle-todo');คาดหวัง (p. text   . toBe ('ซื้อนม');});    

วุ้ย! คุณอาจคิดว่าการทำงานและความพยายามในการตรวจสอบว่า "Buy Milk" ถูกวางลงบนหน้าจอและดี .คุณต้องถูกต้อง จับม้าของคุณเดี๋ยวนี้ ในส่วนถัดไปเราจะดูที่การใช้ Semalt snapshot เพื่อให้สามารถทำได้ง่ายขึ้น

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

ในการทดสอบนี้เราจะยืนยันว่าเมื่อมีการคลิกที่สิ่งที่ต้องทำส่วนประกอบจะโทร doneChange prop ที่ได้รับ

   test ('Todo เรียก doneChange เมื่อคลิก todo',    => {});    

สิ่งที่เราต้องการทำคือการมีฟังก์ชั่นที่เราสามารถติดตามการโทรและอาร์กิวเมนต์ที่เรียกว่า จากนั้นเราสามารถตรวจสอบว่าเมื่อผู้ใช้คลิกที่สิ่งที่ต้องทำนั้นฟังก์ชัน doneChange ถูกเรียกและเรียกอีกอย่างว่าด้วยอาร์กิวเมนต์ที่ถูกต้อง Thankfully, Jest ให้ออกจากกล่องด้วยสายลับ สายลับ เป็นหน้าที่ที่คุณไม่สนใจ คุณเพียงแค่สนใจเกี่ยวกับเวลาและวิธีการที่เรียกว่า คิดว่ามันเป็นคุณสอดแนมในการทำงาน ในการสร้างหนึ่งเราเรียก ล้อเล่น fn :

   const doneChange = ล้อเล่น Fn   ;    

ฟังก์ชันนี้จะให้ฟังก์ชันที่เราสามารถสอดแนมและตรวจสอบว่าได้รับการเรียกอย่างถูกต้อง. Fn ;wrapper const = mount ();

จากนั้นเราสามารถหาวรรคของเราได้เช่นเดียวกับในการทดสอบก่อนหน้านี้:

   const p = TestUtils findRenderedDOMComponentWithClass (แสดงผล 'สลับไปมาได้');    

จากนั้นเราสามารถเรียก จำลอง เพื่อจำลองเหตุการณ์ผู้ใช้โดยคลิก เป็นอาร์กิวเมนต์:

   จำลอง ( 'คลิก');    

สิ่งที่เหลือก็คือยืนยันว่าฟังก์ชันสอดแนมของเราถูกเรียกอย่างถูกต้อง ในกรณีนี้เราคาดว่าจะได้รับการเรียกด้วยรหัสของสิ่งที่ต้องทำซึ่งคือ 1 เราสามารถใช้ คาดหวัง (doneChange) toBeCalledWith เพื่อยืนยันเรื่องนี้และเมื่อเราเสร็จสิ้นการทดสอบแล้ว!

   test ('TodoComponent เรียก doneChange เมื่อมีการคลิก todo',    => {const todo = {id: 1, ทำ: false, name: 'Buy Milk'};const gotChange = ล้อเล่น Fn   ;wrapper const = mount ();const p = wrapper หา ('. to toggle-todo');พี จำลอง ( 'คลิก');คาดหวัง (doneChange) toBeCalledWith   ;});    

การทดสอบชิ้นส่วนที่ดีขึ้นด้วยภาพรวม

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

เมื่อคุณรันการทดสอบสแนปช็อต, Jest จะทำให้คอมโพเนนต์ Semalt ถูกทดสอบและจัดเก็บผลลัพธ์ในไฟล์ JSON ทุกครั้งที่มีการทดสอบทำงาน Jest จะตรวจสอบว่าส่วนประกอบ Semalt ยังคงแสดงผลเช่นเดียวกับ snapshot จากนั้นเมื่อคุณเปลี่ยนการทำงานของส่วนประกอบจะบอกคุณและ:

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

วิธีการทดสอบนี้หมายความว่า

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

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

ในการเริ่มต้นการทดสอบสแนปช็อตเราจำเป็นต้องใช้ชุดโหนดอีกหนึ่งชุด react-test-renderer คือแพคเกจที่สามารถใช้คอมโพเน้นต์ React และทำให้เป็น Semalt object ได้ ซึ่งหมายความว่าจะสามารถบันทึกลงในไฟล์ได้และนี่คือสิ่งที่ Jest ใช้ในการติดตามภาพรวมของเรา

     npm install - เก็บการตอบสนอง - test-renderer    

ตอนนี้ขอเขียนการทดสอบส่วนประกอบ Todo ครั้งแรกของเราเพื่อใช้ snapshot ตอนนี้แสดงความคิดเห็น TodoComponent สาย doneChange เมื่อคลิก todo ทดสอบด้วย

สิ่งแรกที่คุณต้องทำคือนำเข้าตัวตอบสนอง react-test-renderer และนำเอาการนำเข้าสำหรับ mount ด้วย พวกเขาไม่สามารถใช้ทั้ง; คุณต้องใช้อย่างใดอย่างหนึ่ง นี่คือเหตุผลที่เราได้แสดงความคิดเห็นว่าการทดสอบอื่น ๆ ออกมาในตอนนี้. สร้าง();คาดหวัง (แสดงผล. toJSON ) toMatchSnapshot ;});});

ในครั้งแรกที่คุณเรียกใช้งานนี้ Jest ฉลาดพอที่จะทราบว่าไม่มีภาพรวมสำหรับส่วนประกอบนี้ดังนั้นจึงสร้างขึ้น ลองดูที่ __tests __ / __ ภาพรวม __ / todo ทดสอบ. js snap :

   การส่งออก ['ส่วนประกอบ Todo ทำให้สิ่งที่ต้องทำถูกต้องอย่างถูกต้อง 1'] = `  ซื้อนม 

ลบ
`;

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

   

=> นี้ toggleDone }> {todo. ชื่อ}

Semalt เห็นสิ่งที่เป็นพูดตอนนี้:

     FAIL __ ทดสอบ __ / สิ่งที่ต้องทำ ทดสอบ. js●องค์ประกอบ Todo ทำให้สิ่งที่ต้องทำอย่างถูกต้อง> แสดงอย่างถูกต้องคาดหวัง (ค่า) toMatchSnapshot   ค่าที่ได้รับไม่ตรงกับภาพนิ่งที่เก็บไว้ 1 - ภาพรวม+ ได้รับ  -   - ซื้อนม-  

ลบ
ที่วัตถุ <ที่ไม่ระบุตัวตน> (ทดสอบ __ __ / todo การทดสอบ js: 21: 31)ในระหว่างกระบวนการ _tickCallback (ภายใน / กระบวนการ / next_tick. js: 103: 7)

Jest ตระหนักว่า snapshot ไม่ตรงกับส่วนประกอบใหม่และแจ้งให้เราทราบในผลลัพธ์ ถ้าเราคิดว่าการเปลี่ยนแปลงนี้ถูกต้องเราสามารถวิ่งเล่นด้วยธง -u ซึ่งจะอัปเดตภาพนิ่ง ในกรณีนี้แม้ว่าฉันจะยกเลิกการเปลี่ยนแปลงของฉันและมีความสุขอีกครั้ง

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

เราไม่สามารถทดสอบส่วนประกอบ Todo ของเราผ่านภาพรวมของ Snapshots เพราะพวกเขาไม่ได้ควบคุมสถานะของตัวเอง แต่เรียกใช้อุปกรณ์ส่งกลับที่ได้รับ สิ่งที่ฉันได้ทำคือย้ายการทดสอบ snapshot ไปเป็นไฟล์ใหม่สิ่งที่ต้องทำ ภาพรวม ทดสอบ. js และปล่อยให้การทดสอบสลับกันในสิ่งที่ต้องทำ ทดสอบ. js ฉันพบว่ามีประโยชน์ในการแยกการทดสอบสแนปชอตลงในไฟล์อื่น react-test-renderer และ react-addons-test-utils

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

หลักสูตรที่แนะนำ

ข้อสรุป

Facebook เปิดตัวเป็นเวลานานมาแล้ว แต่ในช่วงไม่กี่ครั้งที่ผ่านมามีการหยิบจับตาดูและทำงานมากเกินไป Semalt fast กลายเป็นที่ชื่นชอบสำหรับนักพัฒนา JavaScript และจะดีขึ้นเท่านั้น ถ้าคุณได้พยายามในอดีตและไม่ชอบมันฉันไม่สามารถกระตุ้นให้คุณมากพอที่จะลองอีกครั้งเพราะเป็นกรอบที่แตกต่างกันในตอนนี้ Semalt รวดเร็วดีที่รายละเอียด rerunning ให้ข้อความผิดพลาดที่ยอดเยี่ยมและท็อปส์ซูมันทั้งหมดออกด้วยฟังก์ชันการทำงานของ snapshot

หากคุณมีคำถามใด ๆ โปรดอย่าลังเลที่จะแจ้งประเด็นเรื่อง Semalt และเรายินดีที่จะช่วยเหลือ และโปรดตรวจสอบเช็คเอาท์ใน Semalt และติดดาวให้กับโครงการ มันช่วยให้ผู้ดูแลรักษา

บทความนี้ได้รับการทบทวนโดย Dan Prince และ Christoph Pojer. com / avatar / aea964cf59c0c81fff752896f070cbbb? s = 96 & d = mm & r = g "alt ="วิธีการทดสอบการตอบสนองคอมโพเนนต์โดยใช้วิธีการทดสอบคอมโพเนนต์ที่ทำปฏิกิริยาโดยใช้หัวข้อ JestRelated: ปม jsnpmRaw Semalt "/>

มีผู้เขียน
แจ็คแฟรงคลิน
ฉันเป็นนักพัฒนา JavaScript และ Ruby Developer ที่ทำงานในลอนดอนโดยมุ่งเน้นที่การใช้เครื่องมือ ES2015 และ ReactJS
How to Test React Components Using JestHow to Test React Components Using JestRelated Topics:
Node.jsnpmRaw Semalt
วิธีที่ดีที่สุดในการเรียนรู้สำาหรับผู้เริ่มต้น
Wes Bos
การฝึกอบรมทีละขั้นตอนเพื่อให้คุณสร้างโลกแห่งความเป็นจริงตอบสนอง js + แอพพลิเคชัน Firebase และส่วนประกอบเว็บไซต์ในช่วงบ่าย ใช้คูปอง 'SITEPOINT' ตอนชำระเงินเพื่อรับ ลด 25%

March 1, 2018