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

การทดสอบด้วยโปรแกรมเว็บดูเหมือนการประเมินองค์ประกอบด้วยภาพและการประเมินเชิงประจักษ์ของการใช้งานจริงของฟังก์ชัน Tobto ในการเปลี่ยนแปลงไปตามหน่วยงานและscoєnnі diy เหนือองค์ประกอบไดนามิก

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

วิธีการ Іsnuyu 2 เพื่อกระตุ้นสถานการณ์การทดสอบ:

• กล่องสีขาวการทดสอบ– การทดสอบข้อเขียนขึ้นอยู่กับการใช้งานฟังก์ชัน โต๊บโต. เราแก้ไขอัลกอริทึมเดียวกันซึ่งจะมีโมดูลหุ่นยนต์ของระบบของเรา pidhid ดังกล่าวไม่รับประกันความถูกต้องของระบบหุ่นยนต์
• กล่องดำการทดสอบ- การสร้างสถานการณ์ขึ้นอยู่กับข้อกำหนดและความสามารถของระบบ ดังนั้นจึงเป็นไปได้ที่จะตรวจสอบความถูกต้องของผลงานและโปรแกรมทั้งหมด pidkhid ที่คล้ายกันไม่อนุญาตให้มีการให้อภัยอื่น ๆ และเป็นพื้นฐาน

โช เทสตูวาติ

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

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

ในลำดับนี้ เป็นไปได้ที่จะกำหนด 3 vipadki หากการทดสอบหน่วยถูกต้อง:

1) ในฐานะพ่อตา ให้โอกาสแสดงการให้อภัย ต่ำกว่าสำหรับเรื่องตลกที่ดี

2) ลดชั่วโมงเพื่อความสุข

3) ให้คุณทดสอบโค้ดที่เปลี่ยนแปลงบ่อย

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

ยัก เทสวาตี

เมื่อแจ้งสถานการณ์จำลองให้ดำเนินการทดสอบ ให้ปฏิบัติตามหลักการต่อไปนี้:

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

ชิม เทสตูวาติ

สำหรับการทดสอบหน่วย js-code มีไลบรารีไม่กี่ตัว บางทีกว้างที่สุดคือ QUnit ในการดำเนินการทดสอบหน่วยเพื่อขอความช่วยเหลือจากไลบรารี เราจำเป็นต้องสร้าง "pisochnitsa" - ด้าน html ธรรมดา ซึ่งจะมีไลบรารีสำหรับการทดสอบ รหัสที่ต้องทดสอบ และพลังของ ทดสอบตัวเอง

ฟังก์ชั่นสำหรับการทดสอบ:

(ฟังก์ชัน() ( window.stepen = ฟังก์ชัน(int) ( var ผลลัพธ์ = 2; สำหรับ (var i = 1; i)< int; i ++) { result = result * 2; } return result; } window.returnFunc = function() { return "ok"; } })();

รายการทดสอบ:

ทดสอบ ("ขั้นตอน ()", ฟังก์ชัน () ( เท่ากับ (ขั้นตอน (2), 4, "2^2 - วิธีเท่ากับ"); ตกลง (ขั้นตอน (3) === 8, "2^3 - วิธีตกลง" );deepEqual(สเต็ป(5), 32, "2^5 - วิธี deepEqual"); )); asyncTest("returnFunc()", function() ( setTimeout(function() ( เท่ากับ(returnFunc(), "ตกลง", "Async Func Test"); start(); ), 1000); ));

อย่างที่คุณเห็น QUnit รองรับ 3 ฟังก์ชันเพื่อจับคู่ผลลัพธ์ของรหัสที่ตรงกันพร้อมการตรวจสอบความถูกต้อง:

• ตกลง()– ตรวจสอบว่าการทดสอบสำเร็จหรือไม่ หากผลลัพธ์เป็นเทิร์น = จริง
• เท่ากัน()- จับคู่ผลลัพธ์กับการให้คะแนน
• ลึกเท่ากัน()- จับคู่ผลลัพธ์กับการให้คะแนน ตรวจสอบประเภทอีกครั้ง

ผลลัพธ์ของ vikonanny:

อย่างที่คุณเห็น ไลบรารี QUnit ดำเนินการทดสอบโค้ดหนึ่งครั้งสำหรับเบราว์เซอร์จำนวนหนึ่ง

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

เป็นสิ่งสำคัญที่ต้องจำ

ลักษณะเฉพาะของรหัส js ปัจจุบันคือลักษณะแบบอะซิงโครนัสของการสร้างภาพข้อมูล ไลบรารีสำหรับการทดสอบอาจทำการทดสอบแบบอะซิงโครนัสได้ ตัวอย่างเช่น หากคุณพยายามประท้วงฟังก์ชัน เช่น ส่งคำขอ get ไปยังแบ็กเอนด์แล้วเปิดใช้งานอีกครั้ง จากนั้นเพื่อดำเนินการทดสอบ คุณสามารถเรียกใช้ฟังก์ชัน stop() เรียกใช้ฟังก์ชันที่กำลังดำเนินการอยู่ ทดสอบแล้วรีสตาร์ทกระบวนการโดยใช้ start( ) , "Wrapped Yogo" ใน setTimeout() โต๊บโต. คุณมีความผิดในการวางช่องว่างดังกล่าวเป็นชั่วโมง โดยช่วงนั้นฟังก์ชันจะเสร็จสมบูรณ์ จำเป็นต้องเลือกสิ่งเล็กน้อยของการคดเคี้ยวนี้อย่างขยันขันแข็ง .k จากด้านหนึ่ง หุ่นยนต์ลองใช้วิธีนี้ เป็นไปได้ เป็นภาวะเอกฐานและกระตุ้นให้เกิดความจำเป็นสำหรับการใช้งานเฉพาะของฟังก์ชันการรายงาน และพฤติกรรมที่ไม่ถูกต้อง

ทดสอบ Add-on ของ Backbone

เพื่อจุดประสงค์ในการทดสอบส่วนเสริมที่เขียนด้วยแฮ็ก Backbone.js เราจะอธิบายโครงการใน

การทดสอบแบบแยกส่วนสามารถทดสอบได้:

• ความถูกต้องของการสร้างแบบจำลองและตัวควบคุม
• ความถูกต้องของข้อมูลสำหรับแบบจำลอง
• วิธีการควบคุม Vikonannya (ซึ่งคุณสามารถเปลี่ยนผลลัพธ์ได้)
• ความสำเร็จของความสนใจ

รหัสทดสอบ:

ทดสอบ ("Backbone.js", ฟังก์ชัน () ( ตกลง (ตัวอย่าง, "ตรวจสอบเนมสเปซ"); ตกลง (sample.routers.app, "ตรวจสอบเราเตอร์")); ตกลง (sample.core.pageManager.open ("แชท" ) , "การทดสอบการเปิดหน้า (การเรียกเมธอดของตัวควบคุม)") ok(sample.core.state, "Model check"); "); html(data); return data; )) ), "การตรวจสอบการโหลดเทมเพลต");

ผลการทำงานกับการทดสอบการให้อภัย:

ทดสอบการทำงานอัตโนมัติ

ตามกฎแล้ว การจัดการโปรแกรมมีไว้สำหรับผู้จัดการ เนื่องจากจำเป็นต้องทำบ่อยๆ ด้วยการเติบโตอย่างเข้มข้น ดังนั้นให้ดำเนินการนี้โดยอัตโนมัติ Mimic Jenkins เป็นเครื่องมือสำหรับการผสานรวมที่ไร้รอยต่อ แนวคิดนี้ขึ้นอยู่กับการปรับใช้ผ่าน Jenkins จากการทดสอบอัตโนมัติที่ดำเนินการ

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

/** * Timeout Test Mind เป็นจริงหรือ Timeout เกิดขึ้น * มีประโยชน์สำหรับการรอ * ในการตอบสนองของเซิร์ฟเวอร์หรือการเปลี่ยนแปลง ui (fadeIn เป็นต้น) ที่จะเกิดขึ้น * * @param testFx เงื่อนไขจาวาสคริปต์ที่ประเมินเป็นบูลีน * สามารถส่งผ่านเป็นสตริง (เช่น: "1 == 1" หรือ * "$("#bar").is(":visible")" หรือ * เป็นฟังก์ชันการโทรกลับ (":visible")" หรือ * เป็นฟังก์ชันการโทรกลับ * @param timeOutMillis ระยะเวลาสูงสุดในการรอ หากไม่ได้ระบุ * จะใช้ 3 วินาที = timeOutMillis ?timeOutMillis: 3001, //< Default Max Timout is 3s start = new Date().getTime(), condition = false, interval = setInterval(function() { if ((new Date().getTime() - start < maxtimeOutMillis) && !condition) { // If not time-out yet and condition not yet fulfilled condition = (typeof(testFx) === "string" ? eval(testFx) : testFx()); //< defensive code } else { if(!condition) { // If condition still not fulfilled // (timeout but condition is "false") console.log(""waitFor()" timeout"); phantom.exit(1); } else { // Condition fulfilled (timeout and/or condition is //"true") console.log(""waitFor()" finished in " + (new Date().getTime() - start) + "ms."); typeof(onReady) === "string" ? eval(onReady) : onReady(); //< Do what it"s supposed to do once the // condition is fulfilled clearInterval(interval); //< Stop this interval } } }, 100); // repeat check every 250ms }; }; if (phantom.args.length === 0 || phantom.args.length >2) console.log("การใช้งาน: run-qunit.js URL"); phantom.exit(); ) var page = หน้าเว็บใหม่ (); // กำหนดเส้นทางการเรียก "console.log()" จากในหน้า // บริบทไปยังบริบท Phantom หลัก (เช่น ปัจจุบัน "นี้") page.onConsoleMessage = function(msg) ( console.log(msg); ); page.open(phantom.args, function(status)( if (status !== "success") ( console.log("Unable to access network"); phantom.exit(); ) else ( waitFor(function() ( return page.evaluate(function()( var el = document.getElementById("qunit-testresult"); if (el && el.innerText.match("completed")) ( return true; ) return false; )); ), ฟังก์ชัน()( var failedNum = page.evaluate(ฟังก์ชัน()( var el = document.getElementById("qunit-testresult"); console.log(el.innerText); try ( return document.getElementsByClassName("fail" ) ).innerHTML.length; ) catch (e) ( return 0; ) return 10,000; )); phantom.exit((parseInt(failedNum, 10) > 0) ? 1: 0);

ในการแสดงผลลัพธ์ในคอนโซลเกี่ยวกับผลลัพธ์ของสคริปต์พร้อมการทดสอบ จำเป็นต้องเพิ่มฟังก์ชันการบันทึก

การทดสอบโค้ด- วงจรการพัฒนาที่มองไม่เห็น ซอฟต์แวร์. นักพัฒนาส่วนใหญ่มักจะประเมินบทบาทของมันต่ำเกินไปและแก้ไขการใช้งานจริงของโปรแกรมด้วยวิธีเดิม - "ฝึกฝน ดีแล้ว" ในช่วงแรก กลยุทธ์นี้ได้รับความนิยมและตัวติดตามบั๊กเริ่มทำให้กองทัพรถแทรกเตอร์ที่ไม่มีชื่อหายใจไม่ออก อย่ากินพาสต้าแบบนี้ฉันขอแนะนำให้ศึกษาความแตกต่างของการทดสอบทุกครั้ง จาวาสคริปต์รหัส.

JavaScript ไม่เหมือนกัน

วันนี้ จาวาสคริปต์- ไม่ใช่แค่ mova สำหรับ povzhavlennya มีสติมองโปรแกรม ชั่วโมงที่ JavaScript ถูกแฮ็กสำหรับการทอดหรือเตรียมเมนูนั้นหมดไปอย่างถาวร ตอนนี้เป็นภาษาอิสระ แต่เป็นการดีที่จะฝึกฝนทั้งบนไคลเอนต์และบนเซิร์ฟเวอร์ บทบาทของ JavaScript ได้รับการส่งเสริมอย่างต่อเนื่อง ซึ่งหมายความว่าเมื่อเขียนโค้ด ไม่จำเป็นต้องกังวลกับแนวทางปฏิบัติที่ได้รับการพิสูจน์แล้วว่าดีในภาษาโปรแกรมอื่นๆ

ฉันจะทำอะไรได้บ้างเกี่ยวกับแนวปฏิบัติและกระบวนทัศน์ เทมเพลตสถาปัตยกรรม MVC (ตัวควบคุมมุมมองแบบจำลอง)รหัสองค์กรรูปแบบนั้น ทำตามเคล็ดลับที่ยุ่งยากนี้ คุณจะสามารถเขียนโค้ดที่ดีขึ้นได้ ซึ่งไม่เพียงแต่จะบำรุงรักษาง่าย แต่ยังสร้างขึ้นเพื่อการทดสอบอัตโนมัติอีกด้วย

ขออภัยสำหรับผู้ทดสอบเพิ่มเติม

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

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

ในลักษณะนี้โปรแกรมเมอร์จะฉวยโอกาสแสดงแต่คำขอโทษอย่างหยาบคาย น่าเสียดายที่ koristuvach ที่ "โง่เขลา" และ "ไม่มีประสิทธิภาพ" รวมถึงความฉลาดแกมโกงในตรรกะทางธุรกิจ ใน 99% ของสุนทรพจน์ถูกทิ้งไว้เบื้องหลัง

การปรากฏตัวของบุคคล okremoi ในบุคคลของผู้ทดสอบยังทำลายปัญหาบ่อยครั้งจนถึงเวลาร้องเพลง หากคุณต้องการแสดงความเคารพช่างฝีมือในรายละเอียด คุณภาพของการทดสอบของคุณจะลดลงเหลือศูนย์ด้วยการเพิ่มภาคผนวก ฉันจะยกตัวอย่างจากการปฏิบัติ

เหมือนได้รับความไว้วางใจให้พัฒนาโปรแกรมเล็กๆ สำหรับการทำงานของโครงการ การเดา CRM ที่ง่ายที่สุด วิธีที่ฉันรู้ระยะเวลาที่สั้นที่สุด เมื่อออกจากไร่องุ่นแล้วฉันก็มอบวันหยุดพักผ่อนให้กับรองผู้อำนวยการและลืมเกี่ยวกับโครงการในเดือนฤดูใบไม้ผลิ Dali เริ่มnaytsіkavіshe Zamovnik Virishiv ขยายการทำงานของโปรแกรมอย่างจริงจังและโทรหาฉันเพื่อขอความช่วยเหลือ โดยธรรมชาติแล้วฉันรับและเริ่มทำงานใหม่หลังเลิกงาน ด้านหลังของศีรษะไม่สอดคล้องกัน แต่ถ้ามันไปรวมกันอย่างลึกซึ้งของฟังก์ชั่นกระเป๋าที่กระดิกกระเดี้ยก็พุ่งเข้าหาbіkของฉัน รหัส Shmatki เริ่มขัดแย้งกัน และเป็นไปได้ที่จะเสียเวลามากในการแก้ไขข้อขัดแย้ง “แต่ถ้าคุณไม่ใช่ปริญญาตรี ไส้ติ่งของคุณมีปัญหาอะไร” - ขอเรียนท่านผู้อ่านที่เคารพ หลังจากเปิดตัว แต่ด้วยภาคผนวกที่เติบโตขึ้น ฉันไม่ต้องใช้เวลาหนึ่งชั่วโมงซ้ำซากจำเจและประหม่าเพื่อประท้วงการทำงานทั้งหมดที่มีมากมาย ฉันเข้าไปยุ่งกับการทดสอบฟังก์ชันน้อยกว่าสองสามอย่างและยอมจ่ายในราคานี้อย่างไม่เห็นแก่ตัว คุณธรรมของนิทานคือ "คิดว่าการทดสอบเป็นส่วนที่มองไม่เห็นของการพัฒนา"

Unit testi yak sribna kulya

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

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

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

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

เทสตี้! = รหัสเริ่มต้น

Rozrobnikov, yakіไม่ใช่ vikoristovuyut unit-testuvannya, รัก stverzhuvaty, การทดสอบหน่วย scho การเขียนvmagaєและรหัสpіdtrimki dodatkovogo Movlyav คำศัพท์ในโครงการจริงมักเป็นแบบโวหารและการเขียนโค้ดขั้นสูงนั้นเป็นไปไม่ได้

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

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

ไม่ได้ทดสอบรหัสทั้งหมด

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

QUnit - คลาสสิกของประเภทจากผู้สร้าง jQuery

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

ความได้เปรียบ รุ่นที่เหลือคุณสามารถใช้ QUnit ได้จากเว็บไซต์ทางการ - http://qunitjs.com/ ไลบรารีจัดทำโดยดูที่ JS หนึ่งตัว ไฟล์ css. สมมติว่าคุณได้เรียนรู้จากส่วนประกอบที่จำเป็นแล้ว และถ้าใช่ ก็ถึงเวลาเขียนแบบทดสอบทดลอง อย่าไปไกลและพยายามประท้วงการคาดเดาของฟังก์ชัน trim()

เพื่อสาธิตการทดสอบ ฉันสร้างโปรเจ็กต์ที่ง่ายที่สุดจากตัวสร้างถัดไป:

Index.html - ไฟล์หลักซึ่งแสดงผลการทดสอบ - qunit-1.12.0.js – ไฟล์ไลบรารี qunit; - example.js - ไฟล์สำหรับทดสอบโค้ดสำหรับการทดสอบ (เช่น คำอธิบายของฟังก์ชัน trim()) - test.js - ไฟล์พร้อมการทดสอบ - qunit-1.12.0.css - สไตล์สำหรับการออกแบบดาวพร้อมการทดสอบ

ในไฟล์ index.html และ test.js ของการแทนค่าในรายการ 1 และ 2 พวกเราส่วนใหญ่คลิกที่รายการอื่นซึ่งมีฟังก์ชันที่กำลังทดสอบอยู่ (trim()) และโค้ดของการทดสอบเพื่อตรวจสอบการปฏิบัติจริง ชี้ให้เห็น พูดตามตรง ฟังก์ชัน trim() เองอาจล้าสมัย ฉันจะใส่ไว้ในรายการอื่นเพื่อประหยัดพื้นที่ในนิตยสาร

ทีนี้มาดูการทดสอบกัน สำหรับการยืนยันzdіysnennyaของ praceszdatnosti ของรหัสของเรา qunit.jsสอนวิธีการที่ต่ำแก่เรา:

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

รายการ 1. ในไฟล์ index.html

รายการ 2. ทดสอบไฟล์และฟังก์ชัน trim()

3 การทดสอบ ฟังก์ชั่นง่ายๆ nachebto razіbralisya ยอมรับฉันไม่ต้องเพิ่มอะไรอีก จากนั้นคุณจะต้องใช้รหัสจริงและลองเขียนการทดสอบด้วยตัวเอง เราประหลาดใจกับสิ่งอื่น มักจะตำหนิงานก่อน จาวาสคริปต์- ผู้ค้าปลีก - ทดสอบฟังก์ชันอะซิงโครนัส โปรแกรมนี้เต็มไปด้วยรหัส JavaScript 99% โต้ตอบกับส่วนเซิร์ฟเวอร์เพื่อขอความช่วยเหลือจาก Ajax นอกจากนี้ยังเป็นไปไม่ได้ที่จะละทิ้งโค้ดโดยไม่มีการยืนยันซ้ำ แต่การเขียนแบบทดสอบดูเหมือนเป็นสามอย่าง ลองดูตัวอย่าง:

AsyncTest("myAsyncFunc()", function() ( setTimeout(function() ( ok(myAsyncFunc() == จริง, "ข้อมูลผ่านสำเร็จ"); start(); ), 500); ));

สิ่งสำคัญคือการตรวจสอบก้นของด้านหน้า - การห่อ test() จะถูกแทนที่ด้วย asyncTest() ซึ่งตัวมันเองประกาศว่าเป็นการทดสอบแบบอะซิงโครนัสน้อยกว่าในการทดสอบ ต่อไปฉันเริ่มชั่วโมงของochіkuvannya 500 มล. วินาที เป็นเวลาหนึ่งชั่วโมง ฟังก์ชัน myAsyncFunc() มีหน้าที่ส่งข้อมูลไปยังเซิร์ฟเวอร์ทดสอบ และทุกอย่างก็กลายเป็นจริง แกนนี่มาเองครับ ฟ้องในขณะนี้. เมื่อมีการเรียกใช้การเรียก asyncTest() การเรียกใช้จะดำเนินต่อไป และหลังจากการทดสอบเสร็จสิ้น คุณต้องเรียกใช้ด้วยตนเอง สำหรับการควบคุมการไหล คิวนิตє start() และ stop() วิธีการ

ทดสอบฟังก์ชันอะซิงโครนัสด้วยความช่วยเหลือของไลบรารี คิวนิตมันง่ายที่จะชนะ ส่วนที่เหลือของก้นซึ่งฉันต้องการวาดเพื่อผูกจากการทดสอบข้อเขียนซึ่ง vikonu a kіlkaของperevіrokแบบอะซิงโครนัส อาหารขยะ ราวกับว่ากล่าวโทษ tsimu จากงานที่คล้ายกัน เป็นสถานที่ที่ดีที่สุดในการเริ่มต้นกระแสของ vikonannya เอกสารอย่างเป็นทางการสนับสนุนให้คุณหยุดในสถานการณ์เช่นนี้:

AsyncTest("myAsyncFunc()", function() ( คาดว่า(3); // การทดสอบซ้ำสามครั้งที่นี่ ok(myAsyncFunc(), "Light is better than 1"); ok(myAsyncFunc(), "Light is better than 2 ") ) ok(myAsyncFunc(), "ควรเร็วกว่า 3"); setTimeout(function() ( start(); ), 3000); ));

ทดสอบสำหรับ DIY koristuvach

โปรดทราบว่า JavaScript เขียนด้วยอินเทอร์เฟซจำนวนมาก ตัวอย่างเช่น koristuvach คลิกที่pіmpіและในเวลาเดียวกันเมื่อคลิก yogo สามารถเป็นสถานะได้ รหัส "ส่วนต่อประสาน" ที่คล้ายกันในโครงการนั้นสมบูรณ์เกินไปและจำเป็นต้องครอบคลุมด้วยการทดสอบ มาสงสัยว่าคุณจะจำลองการโจมตีของคีย์และเขียนการทดสอบสำหรับคีย์นี้ได้อย่างไร เราจะเห็นว่าเราสามารถเป็นฟังก์ชันได้ เช่น ถ้ามีการกดปุ่ม Її รหัสที่ฉันพบในรายการที่สาม:

รายการ 3. การบันทึกการกดแป้นพิมพ์

ตอนนี้เรามาลองใช้ฟังก์ชันการประท้วงนี้กัน จำไว้นะ ในการทดสอบนี้ เราจำเป็นต้องกำจัดปุ่มที่กดออกไป ขอความช่วยเหลือจากห้องสมุดได้ง่ายขึ้น jQueryซึ่งช่วยให้คุณสร้างพ็อดในแถวของรหัสคิลคา (รายการ div. 4)

รายการ 4. รหัสทดสอบสำหรับ KeyLogger

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

DOM สำหรับการทดสอบอย่างใกล้ชิด

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

Test("การเพิ่มองค์ประกอบ div ใหม่", function() ( var $fixture = $("#qunit-fixture"); $fixture.append("

Phantom.JS - เรียกใช้การทดสอบจากคอนโซล

เขียนแบบทดสอบสำหรับความช่วยเหลือของห้องสมุด qunit.jsด้วยตนเองและเรียบง่าย, แต่เนิ่นๆ chi pizno її คุณเห็นความจำเป็นในการเปิดใช้งานการทดสอบและการเลือกผลลัพธ์โดยอัตโนมัติ ตัวอย่างเช่นฉันต้องช่วย เครื่องเสมือนใน DigitalOcean สิ่งที่ฉันสามารถทำได้เพื่อขอความช่วยเหลือจากคอนโซล

โครงการ phantom.js ช่วยให้คุณสามารถแก้ปัญหานี้ได้อย่างสง่างาม Tse ไม่ใช่กรอบสำหรับการเขียน การทดสอบหน่วยและเวอร์ชันเต็มคอนโซลของเครื่องยนต์ เว็บคิต. พูดง่ายๆ ก็คือ โปรแกรมนี้เป็นเบราว์เซอร์ สำหรับความช่วยเหลือของ phantom.js จริงๆ แล้ว ไม่ใช่แค่การทำให้การตรวจสอบซ้ำของการทดสอบเป็นไปโดยอัตโนมัติเท่านั้น แต่ยังทำให้งานที่ไม่มีตัวตนล้มเหลวด้วย เร็วเกินไปที่จะตำหนิผู้ค้าปลีก: ลบผลลัพธ์จากการแสดงด้านข้างของ a ไฟล์ (png, jpg) ฟังก์ชั่นของจอภาพการเรียงต่อกัน (ความกว้างจะพันกัน บางก็มีประสิทธิภาพ) เป็นต้น) การเลียนแบบ DIY koristuvach toshcho ฉันขอแนะนำว่าอย่าสาบานและอ่านเอกสารอย่างเป็นทางการสำหรับโครงการใด ๆ ที่คุณรู้จักด้วยตัวคุณเอง

Phantom.jsคุณสามารถเลือกแพลตฟอร์มต่างๆ ได้ (nix, mac OS X, windows) หากคุณกำลังขยายทุกอย่างใน Windows แสดงว่าไม่มีปัญหารายวัน - ดาวน์โหลดไบนารีล่วงหน้า ปัญหาเล็กน้อยในการเริ่มต้นอาจเกิดขึ้นได้หากคุณติดตั้งอะแดปเตอร์วิดีโอสองตัว หนึ่งในนั้นคือ NVIDIA วิธีที่คุณแฮ็คอย่างรวดเร็วเราจะอธิบายในvrіzanny

ลองมาทำความรู้จักกับ phantom.js แบบฝึกหัดกัน กระโดดข้ามผ่าน phantom.jsการทดสอบที่เตรียมไว้ในอดีต จากนั้นจึงแสดงผลในคอนโซล เราต้องการตัวโหลดสคริปต์พิเศษ - run-qunit.js เปิดคอนโซล (ฉันใช้ Windows นั่นคือ vicorist cmd) และพิมพ์คำสั่งในรูปแบบ:

phantom.exe<путь к run-qunit.js> <путь к странице с тестами>

ในความคิดของฉัน คำสั่งเรียกใช้มีลักษณะดังนี้:

E:\soft\phantomjs>phantomjs.exe E:\temp\testjsforx\qunit\run-qunit.js file:///E: /temp/testjsforx/qunit/index.html ผลลัพธ์ її vykonannya: การทดสอบเสร็จสิ้นภายใน 2592 มิลลิวินาที . ให้คะแนน 9 จาก 9 ผ่าน 0 ไม่ผ่าน

ผ่านการทดสอบทั้งหมด

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

หากไม่มีเวลาทดสอบ

ในขณะนี้ ไม่มีเหตุผลที่จะเขียนการทดสอบสำหรับฟังก์ชันอย่างง่าย (ใช้ trim() เดียวกันจากแอปพลิเคชันในบทความ) แทนที่จะเน้นไปที่กรณีที่สำคัญที่สุดของโค้ด เลื่อนกฎ Dotrimuvatisya tsgogo เมื่อเขียนรหัสซึ่งมักจะมีการเปลี่ยนแปลง งานด้านเทคนิคของโครงการที่ใช้งานอยู่มักจะมีการเปลี่ยนแปลง และฟังก์ชันจริงต้องได้รับการปรับปรุงอย่างต่อเนื่อง การเปลี่ยนแปลงดังกล่าวอาจทำให้เกิดช่วงเวลาที่ไม่สามารถยอมรับได้ - ด้วยการเปลี่ยนแปลงใหม่ โค้ดทำงานได้ดี แต่โค้ดเก่าจะไม่ถูกสลักมากเกินไป แกน schob ไม่ใส่ร้าย feil ที่นี่ ฟังก์ชั่นที่คล้ายกันมีแนวโน้มที่จะครอบคลุมการทดสอบ จำกฎง่ายๆ - อย่ามีเวลาครอบคลุมโค้ดทั้งหมดด้วยการทดสอบโดยครอบคลุมส่วนที่สำคัญที่สุด

กฎการทดสอบที่ดี

ปัญหา phantom.js บน Windows

มันเกิดขึ้นแล้ว แต่ใช้ทุกอย่างกับสถิติ ฉันไม่ได้ทดสอบใน Linux แต่ภายใต้ Windows 7 รุ่นเก่าที่ดี ดูเหมือนว่า phantom.js อาจมีปัญหาเล็กน้อยเมื่อทำงานบนระบบที่อะแดปเตอร์วิดีโอได้รับชัยชนะ บนแล็ปท็อปของฉันซึ่งเป็นครีมของชิปวิดีโอในตัว NVidia ยังคงแฮงค์เอาท์และผ่าน phantom.js ตอบสนองต่อคำสั่ง phantom.exit() อย่างเด็ดขาด เป็นผลให้กระบวนการ phantom.js ทำงานไม่เสร็จหลังจากที่สคริปต์หมดและยังคงค้างอยู่ในหน่วยความจำ ในเวลาเดียวกัน เทอร์มินัลยังตอบสนองต่อคำสั่งเสร็จสิ้น (ctrl + c - โดยไม่มีความช่วยเหลือ)

คุณติดอยู่กับปัญหาที่คล้ายกันและวางแผนที่จะชนะได้อย่างไร phantom.jsบน Windows จากนั้นเตรียมพร้อมที่จะโจมตีแฮ็คที่น่ารังเกียจ แผงVіdkriy keruvannya Nvidia ค้นหารายการ "การตั้งค่า 3D" ในแผนภูมิ จากด้านขวา ตัวเลือก "สำคัญที่สุด อะแดปเตอร์กราฟิก". สำหรับค่า zamovchuvannyam її ตั้งไว้ที่ "Avtovibor" เราจำเป็นต้องจดจำโปรเซสเซอร์ Nvidia หรือกราฟิกในตัวที่มีประสิทธิภาพสูง หลังจากเคล็ดลับง่ายๆ phantom.jsเริ่มมีพฤติกรรมทางหู

ขณะนี้มีการทดสอบความรู้ในหัวข้อที่กำลังจะมีขึ้นบนเว็บไซต์: HTML, css, จาวาสคริปต์, พี.เอช.พี, เอสคิวแอล.

การทดสอบทางผิวหนังเป็นแบบสะสม 10ฟีดเพลงของพวกเขาเหล่านั้น ฉันได้ลองใช้การบำรุงผิวเพื่อจัดการกับทรงกลมที่น่าดึงดูดที่สุดของภาษาเฉพาะ stosuvannya เพื่อให้คุณสามารถทบทวนความรู้ของคุณได้มากที่สุด

บ้าทุกอย่าง ปราศจากแป้งและผ่านมันไปให้ได้

คำสั่งทดสอบ:

1. ไปขอความช่วยเหลือ Rozpochati เทสตูวันยาในการทดสอบที่ใช้การได้
2. Vіdpіdaєteในการจัดหา เดี่ยวตัวเลือกที่ถูกต้อง
3. หลังจากเสร็จสิ้นการทดสอบ คุณจะยินดีต้อนรับ ลูกของคุณ, จำนวนการให้อภัยเช่นเดียวกับ การเลือกโภชนาการของผิวจากการทดสอบ

เคารพ!ถ้าคุณไม่เห็นมันจนกว่าคุณจะหันไปข้างหน้า คุณต้องพิสูจน์ก่อน ลองคิดดู

พร้อมใช้งานในขณะที่ทำการทดสอบ

1. HTML

   • การทดสอบ Usogo ผ่าน: 75424 คน
   • คะแนนเฉลี่ย: 2.83 จาก 5บาลิฟ

   แบบทดสอบความรู้พื้นฐาน HTML. คุณต้องรู้พื้นฐาน แท็ก HTMLและเรียนรู้เพิ่มเติม їх การเปล่งเสียง นอกจากนี้ยังจำเป็นต้องเข้าใจคุณสมบัติของมาตรฐาน เอ็กซ์เอชทีเอ็มแอล 1.1.

2. css

   • การทดสอบ Usogo ผ่าน: 32828 โอซิบ
   • คะแนนเฉลี่ย: 3.37 จาก 5บาลิฟ

   แบบทดสอบวัดความรู้พื้นฐาน css. ในการผ่านการทดสอบให้สำเร็จ คุณต้องรู้จักประเภทตัวเลือกหลัก (ไวยากรณ์) รู้จักกำลังหลักและค่าที่เป็นไปได้ และรู้จักการจดจำองค์ประกอบเทียมที่ได้รับความนิยมสูงสุดด้วย

3. จาวาสคริปต์

   • การทดสอบ Usogo ผ่าน: 24845 โอซิบ
   • คะแนนเฉลี่ย: 3.31 จาก 5บาลิฟ

   การทดสอบนี้ทดสอบความรู้ของคุณเกี่ยวกับ JavaScript สารอาหารจากแป้งถูกฉีกออกจากกันโดยทรงกลมต่างๆของ stosuvannya tsієї mov อาหารที่สมบูรณ์ยิ่งขึ้นเพื่อความเข้าใจในความแตกต่างของ "dribnih" มิฉะนั้น คุณจะต้องรู้สุนทรพจน์พื้นฐาน: การทำงานกับการเปลี่ยนแปลง, ฟังก์ชันพื้นฐานของ JavaScript, ลำดับความสำคัญของการดำเนินการ และอื่นๆ

4. พี.เอช.พี

   • การทดสอบ Usogo ผ่าน: 33239 โอซิบ
   • คะแนนเฉลี่ย: 3.03 จาก 5บาลิฟ

   การทดสอบนี้จะตรวจสอบความรู้ของคุณเกี่ยวกับภาษา PHP คุณจะต้องมีความรู้หลัก PHP สร้าง, งานเพื่อเปลี่ยนแปลง, เซสชัน, การดำเนินการเปลี่ยนเส้นทางและสุนทรพจน์มาตรฐานอื่นๆ
   Perekonlive โปรฮันยา:ในการทดสอบให้ถามมาก ๆ เพื่อตรวจ: "คุณเขียนสคริปต์ให้ใคร" Prohannya ที่ดี ไม่จำเป็นต้องคัดลอกโยคะและแก้ไข ซื่อสัตย์กับตัวเอง

5. เอสคิวแอล

   • การทดสอบ Usogo ผ่าน: 18014 โอซิบ
   • คะแนนเฉลี่ย: 3.28 จาก 5บาลิฟ

   การทดสอบนี้เป็นการทบทวนความรู้ของคุณเกี่ยวกับภาพยนตร์ แบบสอบถาม SQL. zapitanya tokayutsya น้อยกว่าตัวเอง ความรู้พื้นฐาน tsієїเคลื่อนไหวโดยไม่มีการทำลายล้างใด ๆ คุณต้องมีแบบสอบถาม SQL ที่ทันสมัยที่สุด รวมถึงคำที่มีความสามารถมากขึ้น

І є jQuery เครื่องมือทดสอบอย่างเป็นทางการ Ale QUnit เหมาะสำหรับการทดสอบโค้ด JavaScript และเพื่อเริ่มการทดสอบ JavaScript ฝั่งเซิร์ฟเวอร์ที่อยู่เบื้องหลังกลไกเพิ่มเติม เช่น Rhino หรือ V8

หากคุณไม่ทราบแนวคิดของ "การทดสอบแบบโมดูลาร์" อย่าสับสน - ไม่มีอะไรที่จะเข้าใจได้:

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

อ้างอย่างมีนัยสำคัญจาก Wikipedia เพียงสร้างการทดสอบสำหรับบล็อกการทำงานของสกินของโค้ดของคุณ และทันทีที่การทดสอบทั้งหมดผ่าน คุณจะได้รับการอภัยโทษ (อันดับหลักคือการล้มเลิก นอกจากนี้ การทดสอบที่ค่อนข้างเสียมีกี่แบบ)

ถัดไป ทดสอบรหัสของคุณ

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

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

ในทางกลับกัน ทุกสิ่งที่พยายามทำการทดสอบจะไม่สามารถลองใหม่ได้ สำหรับวิธีการดังกล่าวนั้นยากที่จะทราบการถดถอยอยู่แล้ว การถดถอยคืออะไร? แสดงว่าคุณเขียนโค้ดนี้และคัดค้าน แก้ไข ขอโทษทั้งหมด ตามที่ทราบ พวกเขาโพสต์โค้ดบนไซต์ คำอธิบาย Potim koristuvach nadislav เกี่ยวกับการให้อภัยใหม่และการร้องขอสำหรับฟังก์ชั่นใหม่ คุณหันไปใช้รหัส แก้ไขการให้อภัย และเพิ่มฟังก์ชันใหม่ คุณสามารถตำหนิสถานการณ์กับใครได้ หากการให้อภัยแบบเก่าปรากฏขึ้นอีกครั้ง สิ่งที่เรียกว่า "การถดถอย" คุณจะต้องเขียนทุกอย่างใหม่อีกครั้ง มีโอกาสที่คุณจะไม่รู้จักการให้อภัยเก่าของคุณ ไม่ว่าจะเป็นหนึ่งชั่วโมงก่อนฤดูใบไม้ร่วง ครั้งแรกที่คุณจะเดาว่าปัญหาของ viklikan คือ "การถดถอย" สำหรับหนึ่งชั่วโมงของการทดสอบหน่วย คุณเขียนแบบทดสอบ ทันทีที่โค้ดถูกแก้ไข คุณจะกรองโค้ดอีกครั้งผ่านการทดสอบ หากการถดถอยปรากฏขึ้นแสดงว่าการทดสอบไม่ผ่านและคุณสามารถค้นหาได้อย่างง่ายดายซึ่งเป็นส่วนหนึ่งของรหัสเพื่อล้างแค้นการให้อภัย หากคุณไม่รู้ว่าคุณเปลี่ยนแปลงอะไร การให้อภัยจะแก้ไขได้ง่าย

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

วิธีเขียนการทดสอบหน่วยด้วย QUnit

Otzhe จะเขียนการทดสอบโมดูลใน QUnit ได้อย่างไร ขั้นตอนแรกคือการติดตั้งช่วงกลางของการทดสอบ:

ชุดทดสอบ QUnit

รหัสที่จะทดสอบเพื่อล้างแค้นจากไฟล์ myProject.jsและการทดสอบอยู่ใน myTests.js. ในการเรียกใช้การทดสอบ คุณเพียงแค่ต้องเปิดไฟล์ HTML ในเบราว์เซอร์ ตอนนี้ได้เวลาเขียนแบบทดสอบบางอย่างแล้ว

บล็อกBudіvelnyของการทดสอบแบบแยกส่วน є otverdzennya

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

สำหรับความแข็ง vikonannya їх จำเป็นต้องวางก่อนบล็อกทดสอบ:

// ทดสอบฟังก์ชันนี้ function isEven(val) ( return val % 2 === 0; ) test("isEven()", function() ( ok(isEven(0), "Zero is a good number"); ok ( isEven(2), "Two - tezh"); ok(isEven(-4), "І ลบ chotiri - tezh เท่ากับจำนวน"); ok(!isEven(1), "One - unpaired number"); ok( ! isEven(-7), "จามรีและค่าลบ - จำนวนที่ไม่ได้จับคู่"); ))

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

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

เราเขียนห้าทึบ เรามี є ตรรกะ มีเหตุผลที่จะยืนยันว่าพารามิเตอร์แรกมีค่า จริง. พารามิเตอร์อื่นคือค่าการเตือน ซึ่งเป็นวิธีที่ควรแสดงผลลัพธ์

แกนของสิ่งที่เราทำหลังการทดสอบ:

การยืนยันทั้งหมดของเราได้รับการยืนยันเรียบร้อยแล้ว สามารถพิจารณาได้ว่าฟังก์ชัน isEven() pratsyuєดังนั้นเป็นochіkuvalos

เรามาลุ้นกันว่าถ้าตั้งมั่นผิดจะเป็นยังไง

// ทดสอบฟังก์ชันนี้ function isEven(val) ( return val % 2 === 0; ) test("isEven()", function() ( ok(isEven(0), "Zero is a good number"); ok ( isEven(2), "Two - tezh"); ok(isEven(-4), "І ลบ chotiri - tezh เท่ากับจำนวน"); ok(!isEven(1), "One - unpaired number"); ok( ! isEven(-7), "Yak and Negative sіm - unpaired number"); // Pardon ok(isEven(3), "Three - unpaired number"); ))

Іแกนสิ่งที่เราคำนึงถึงในผลการทดสอบ:

ขออภัยอย่างยิ่ง yaku mi เริ่ม navmisno แต่สำหรับโครงการของคุณ หากคุณไม่ผ่านการทดสอบ แต่ตัดสินใจว่าข้อความทั้งหมดถูกต้อง การให้อภัยก็จะง่ายขึ้น

ความยากลำบากอื่น ๆ

ok() ไม่ใช่สิ่งเดียวที่รองรับ QUnit สร้างความแข็งประเภทอื่นๆ วิธี vicorate ด้วยตนเองเมื่อทดสอบการพับสำหรับโครงการของคุณ:

การยืนยันข้อตกลง

การยืนยันข้อตกลง เท่ากับ ()การถ่ายโอนว่าพารามิเตอร์แรก (ซึ่งเป็นค่าที่ถูกต้อง) เทียบเท่ากับพารามิเตอร์อื่น ๆ (ซึ่งเป็นค่าที่ถูกต้อง) ความแข็งนั้นใกล้เคียงกับ ตกลง() Ale เพื่อแสดงความหมายที่ดูถูก - deisne และ perebachuvane ซึ่งทำให้ง่ายต่อการปรับปรุงรหัส เช่นเดียวกับฉัน ตกลง(), เท่ากับ ()เป็นพารามิเตอร์ที่สาม คุณสามารถจดบันทึกเพื่อดู

ดังนั้น รอง

ทดสอบ ("การยืนยัน", ฟังก์ชัน () ( ตกลง (1 == 1, "หนึ่งเทียบเท่ากับหนึ่ง"); ))

เลื่อนเพื่อชนะ:

ทดสอบ ("ยืนยัน", ฟังก์ชัน () ( เท่ากับ (1, 1, "หนึ่งเท่ากับหนึ่ง"); ))

การให้ความเคารพ เช่น แสดงการถ่ายทอดความหมายต่อกันเป็นแถว.

และยังความหมายไม่เท่ากัน:

ทดสอบ ("ยืนยัน", ฟังก์ชัน () ( เท่ากับ (2, 1, "หนึ่งเท่ากับหนึ่ง"); ))

บันทึกดังกล่าวให้ข้อมูลเพิ่มเติม

การตรวจสอบความถูกต้องของการจับคู่ของตัวดำเนินการจับคู่ "==" สำหรับการตรวจสอบพารามิเตอร์อีกครั้ง ซึ่งสามารถทำได้ด้วยอาร์เรย์ของวัตถุ:

Test("test", function() ( เท่ากับ((), (), "อภัย, วัตถุทั้งหมด"); เท่ากับ((a: 1), (a: 1) , "อภัย"); เท่ากับ( , , " ขอโทษ, tse rіznі array"); เท่ากับ (, , "ให้อภัย");

สำหรับลักษณะการทำงานดังกล่าว QUnit มีเอกลักษณ์ที่มั่นคง

ตัวตนที่มั่นคง

ตัวตนที่มั่นคง เดียวกัน() vikoristova เป็นพารามิเตอร์ที่ฉัน เท่ากับ ()แต่ไม่เฉพาะกับประเภทดั้งเดิม แต่กับอาร์เรย์และวัตถุ ต้องยืนยันการยืนยันจากปืนด้านหน้าอีกครั้ง เพื่อเปลี่ยนการยืนยันตัวตน:

ทดสอบ ("ทดสอบ", ฟังก์ชัน () ( เหมือนกัน ((), (), "ผ่าน, วัตถุแสดงเนื้อหาเดียวกัน"); เหมือนกัน ((a: 1), (a: 1) , "ผ่าน"); เหมือนกัน ( , , "ผ่าน, อาร์เรย์และดึงเนื้อหาเดียวกัน"); same(, , "pass"); ))

เคารพอะไร เดียวกัน()ตัวดำเนินการจับคู่ '===' สำหรับการจับคู่ ดังนั้นคุณสามารถชนะด้วยตนเองสำหรับค่าพิเศษที่ตรงกัน:

ทดสอบ ("ทดสอบ", ฟังก์ชัน () ( เท่ากับ (0, เท็จ, "จริง"); เหมือนกัน (0, เท็จ, "เท็จ"); เท่ากับ (null, ไม่ได้กำหนด, "จริง")); เหมือนกัน (เป็นโมฆะ, ไม่ได้กำหนด, "เท็จ"); ))

โครงสร้าง

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

คุณสามารถจัดระเบียบโมดูลอื่นๆ สำหรับฟังก์ชันเพิ่มเติมได้ โมดูล:

โมดูล ("โมดูล A"); ทดสอบ ("ทดสอบ", ฟังก์ชัน () ()); ทดสอบ ("การทดสอบอื่น", ฟังก์ชัน () ()); โมดูล ("โมดูล B"); ทดสอบ ("ทดสอบ", ฟังก์ชัน () ()); ทดสอบ ("การทดสอบอื่น", ฟังก์ชัน () ());

ที่ก้นด้านหน้า ความแน่นทั้งหมดถูกเรียกออกมาพร้อมๆ กัน ดังนั้นพวกเขาจึงพ่ายแพ้ไปทีละคน โลกแห่งความจริงมีฟังก์ชันแบบอะซิงโครนัสที่ไม่มีตัวตน เช่น คำขอและฟังก์ชัน AJAX setTimeout()і setInterval(). เราจะทดสอบฟังก์ชั่นประเภทนี้ได้อย่างไร? QUnit มีการทดสอบประเภทพิเศษที่เรียกว่า "การทดสอบแบบอะซิงโครนัส" และใช้สำหรับการทดสอบแบบอะซิงโครนัส:

เราสามารถลองเขียนการทดสอบด้วยวิธีที่ชัดเจนที่สุด:

ทดสอบ ("การทดสอบแบบอะซิงโครนัส", ฟังก์ชัน () ( setTimeout (ฟังก์ชัน () ( ตกลง (จริง); ), 100) ))

มองแบบนี้ การทดสอบไม่มีความยากลำบากทุกวัน นั่นเป็นสาเหตุที่การชุบแข็งเป็นแบบซิงโครนัส แต่ในขณะที่การเรียกใช้ฟังก์ชัน การทดสอบได้สิ้นสุดลงแล้ว

ตัวเลือกที่ถูกต้องสำหรับการทดสอบก้นของเรา:

Test("Asynchronous test", function() ( // เปลี่ยนการทดสอบเป็นโหมด "pause" stop(); setTimeout(function() ( ok(true); // หลังจากทวีตเสร็จสิ้น // เริ่มการทดสอบต่อ (); ), 100) ))

เราชนะหน้าที่ หยุด()เพื่อทดสอบการทดสอบ และหลังจากการทดสอบเสร็จสิ้น พวกเขาทำการทดสอบอีกครั้งเพื่อหาฟังก์ชันเพิ่มเติม เริ่ม().

ฟังก์ชันของวิคลิ หยุด()ทันทีหลังจากการทำงานประจำสัปดาห์ ทดสอบ()มีการปฏิบัติอย่างกว้างขวางมากขึ้น ดังนั้น QUnit สามารถย่อให้สั้นลงได้เป็นพิเศษ: asyncTest(). ก้นด้านหน้าสามารถเขียนใหม่ได้เมื่อมองเห็น:

AsyncTest("การทดสอบแบบอะซิงโครนัส", ฟังก์ชัน() ( // การทดสอบจะเข้าสู่โหมด "หยุดชั่วคราว" โดยอัตโนมัติ setTimeout(ฟังก์ชัน() ( ตกลง(จริง); // หลังจากข้อเสนอแนะเสร็จสิ้น // เริ่มการทดสอบต่อ() ; ), 100) )))

Є สักครู่ เหนืออะไร varto zamylitsya: ฟังก์ชั่น setTimeout()เรียกใช้ฟังก์ชันของคุณเสมอ แล้วทดสอบฟังก์ชันอื่น (เช่น แบบสอบถาม AJAX) เราจะแน่ใจได้อย่างไรว่าฟังก์ชัน return จะถูกเรียกออกมา? ในฐานะที่เป็นฟังก์ชันการกลับรายการ จะไม่มี viklikan ฟังก์ชัน เริ่ม()อาจสูญหายได้หากไม่มีการโทรด่วนและ "ส่ง" การทดสอบทั้งหมดแล้ว:

คุณสามารถจัดระเบียบการทดสอบได้ดังนี้:

// ฟังก์ชันการโทรกลับ ฟังก์ชัน ajax(successCallback) ( $.ajax(( url: "server.php", ความสำเร็จ: successCallback )); ) test("การทดสอบแบบอะซิงโครนัส", ฟังก์ชัน() ( // รันการทดสอบและ // กำลังดำเนินการ เพื่อตรวจสอบการให้อภัยเนื่องจากฟังก์ชั่น start() จะไม่ถูกเรียกหลังจาก 1 วินาที stop(1000); ajax(function()

การทำงาน หยุด()ค่าการหมดเวลาผ่านไปแล้ว ตอนนี้ QUnit ได้ลบพรอมต์: "นี่คือฟังก์ชัน เริ่ม()หากไม่มี vyklikan หลังจากหมดเวลา เราจะไม่ผ่านการทดสอบครั้งต่อไป” ตอนนี้การทดสอบทั้งหมดไม่ได้ "ถูกระงับ" และคุณจะเห็นล่วงหน้าราวกับว่ามันไม่เป็นเช่นนั้นอย่างที่ควรจะเป็น

ทีนี้มาดูฟังก์ชั่นอะซิงโครนัสที่หลากหลาย จัดสรรฟังก์ชัน เริ่ม()? จำเป็นต้องวาง її ที่ฟังก์ชัน setTimeout():

// ฟังก์ชันการโทรกลับ ฟังก์ชัน ajax(successCallback) ( $.ajax(( url: "server.php", ความสำเร็จ: successCallback )); ) ทดสอบ("การทดสอบแบบอะซิงโครนัส", ฟังก์ชัน() ( // เรียกใช้การทดสอบหยุด(); ajax (ฟังก์ชัน () ( // ... การโทรกลับแบบอะซิงโครนัส)) ajax (ฟังก์ชัน () ( // ... การโทรกลับแบบอะซิงโครนัส)) setTimeout (ฟังก์ชัน () ( start (); ), 2000);

ก่อนดำเนินการทดสอบ ค่าการหมดเวลาอาจเพียงพอสำหรับการหมุนเวียนทั้งสองฟังก์ชัน หากหน้าที่ใดหน้าที่หนึ่งไม่ได้เป็นวิคลิกัน คุณจะแต่งตั้งอย่างไร จะเป็นตัวคุณเองได้อย่างไร? ฟังก์ชั่นสำหรับใคร คาดหวัง():

// โค้ดฟังก์ชัน function ajax(successCallback) ( $.ajax(( url: "server.php", success: successCallback )); ) test("Asynchronous test", function() ( // Run the test stop(); / / หมายเหตุถึง QUnit ว่าควรสังเกตว่าการคาดหวัง (3); ) ( start(); ), 2000); ))

เราถูกส่งไปยังฟังก์ชัน คาดหวัง()บริษัทkіlkіst, yakіplanuєtsya vikonati เนื่องจากหนึ่งในฐานที่มั่นจะไม่ใช่วิโคนัน คุณจึงต้องดูแลผู้ที่ผิดพลาดตามแผน

Є บันทึกย่อสำหรับวิกิ คาดหวัง(): จำเป็นต้องผ่านปริมาณการชุบแข็งซึ่งวางแผนไว้เป็นพารามิเตอร์อื่น ทดสอบ()หรือ asyncTest():

// ฟังก์ชันการโทรกลับ ฟังก์ชัน ajax(successCallback) ( $.ajax(( url: "server.php", ความสำเร็จ: successCallback )); ) // หมายเหตุถึง QUnit ที่เราเห็นได้ชัดว่ากด 3 การทดสอบ ("การทดสอบแบบอะซิงโครนัส", 3, ฟังก์ชัน () ( // เรียกใช้การทดสอบหยุด (); ajax (ฟังก์ชัน () ( ตกลง (จริง); )) ajax (ฟังก์ชัน () ( ตกลง (จริง); ตกลง (จริง); )) setTimeout (ฟังก์ชัน () ( เริ่ม (); ), 2543); ))

วิสโนวอค

ที่โรงเรียนแห่งนี้ เราได้นำทุกสิ่งที่จำเป็นสำหรับการทำงานด้วย QUnit การทดสอบแบบแยกส่วนเป็นวิธีการมหัศจรรย์สำหรับการทดสอบรหัสซ้ำก่อนที่จะทดสอบ ราวกับว่าคุณไม่เคยชนะการทดสอบประจำปีมาก่อน ถึงเวลาที่ต้องบอกแล้ว

ในตัวอย่างเครื่องคิดเลขอย่างง่ายบน Node.js ทดสอบความช่วยเหลือด้วย Mocha framework

โปรแกรมของเรารวมอะไรบ้าง:

• บวก ดู หาร และคูณ ไม่ว่าจะเป็นเลขสองตัว
• แสดงความก้าวหน้าและทำงานให้เสร็จตามที่ป้อนไว้ก่อนหน้านี้ในหมายเลขเดียวกัน
• นอกจากนี้ยังอาจเป็นอินเทอร์เฟซ บรรทัดคำสั่ง, ช็อบ kіntsevy spozhivachเร่งความเร็วโปรแกรมทันที

เราต้องการอะไร:

• Node.js และ npm;
• ความรู้เกี่ยวกับ JavaScript: ไวยากรณ์และโครงสร้างโค้ด ประเภทของข้อมูล การดำเนินการทางคณิตศาสตร์ และภาษาอัจฉริยะ

ด้วยจุดประสงค์ในการขยายคุณสามารถดำเนินการตั้งค่ากลางสำหรับการทดสอบและการขยาย

ไปวันพุธกันเถอะ

เศษเสี้ยวของ Node.js เลียนแบบ คุณต้องสร้าง Honing ในเครื่องสำหรับไฟล์และฟอลโลว์

สร้าง แฟ้มใหม่ คำนวณ. จากบรรทัดคำสั่ง ไปที่ไดเรกทอรี tsієї และสร้างโครงการใหม่ด้วยคำสั่ง npm init วิธีสร้าง ไฟล์ใหม่ package.jsonสำหรับโปรแกรมของเรา

คุณได้รับพร้อมท์ให้ป้อนชื่อแพ็คเกจ รุ่น คำอธิบาย และข้อมูลอื่น ๆ เกี่ยวกับแพ็คเกจ คุณสามารถใส่ชื่อของคุณ calc.jsและนูนได้ไกลขึ้น เข้าสำหรับค่า nadannya สำหรับ zamovchuvannyam หากคุณได้รับคำสั่งทดสอบให้ป้อน mocha - เฟรมเวิร์กทั้งหมดสำหรับการทดสอบซึ่งเราจะชนะ:

หลังจากป้อนข้อมูลทั้งหมดสคริปต์จะสร้างไฟล์ package.jsonซึ่งมีลักษณะดังนี้:

( "ชื่อ": "calc.js", "เวอร์ชัน": "1.0.0", "คำอธิบาย": "เครื่องคิดเลข Node.js อย่างง่าย", "หลัก": "index.js", "สคริปต์": ( " ทดสอบ ":"มอคค่า" ), "ผู้เขียน": "", "ใบอนุญาต": "ISC" )

ขั้นตอนสุดท้ายในขั้นตอนนี้คือการติดตั้ง Mocha ป้อนคำสั่งถัดไปเพื่อติดตั้ง:

npm ติดตั้ง --save-dev มอคค่า

หลังจากคำสั่ง zastosuvannya tsієї โฟลเดอร์ z'appear node_modules, ไฟล์ package-lock.jsonในขณะที่ไฟล์ package.jsonให้ปรากฏแถวถัดไป:

"devDependencies": ( "มอคค่า": "^4.0.1" )

สร้างไฟล์ ทดสอบ js. เรากำลังเร่งให้รู้จักกับ Node.js ด้วยโมดูล ยืนยันเพื่อย้อนกลับความถูกต้องของความเท่าเทียมกันจริงและจริง ถูกต้องมากขึ้น การทดสอบสามารถผ่านได้สำเร็จ:

Const ยืนยัน = ต้องการ ("ยืนยัน"); it("อาจกลายเป็นจริง", () => ( assert.equal(จริง, จริง); ));

ตอนนี้รันการทดสอบจากบรรทัดคำสั่ง:

การทดสอบ $ npm > mocha ✓ เปิดจริง 1 ผ่าน (8ms)

การทดสอบผ่านไปราวกับว่ามันโล่งขึ้นดังนั้นช่วงกลางจึงเสร็จสิ้น ดูจาก ทดสอบ jsทุกอย่าง krim แถว const assert = ต้องการ ("ยืนยัน"); .

เราจะทวีตไฟล์ ทดสอบ jsโดยยืดขั้นตอนการสร้างโปรแกรม สร้างอีกสองไฟล์: operation.jsสำหรับฟังก์ชันเลขคณิตและการตรวจสอบ และ calc.jsสำหรับตัวโปรแกรมเอง เรา vikoristovuemo ยื่นอย่างมั่งคั่งเพื่อให้กลิ่นเหม็นไม่ยาวเกินไปและพับได้ แกนของรายการไฟล์ปัจจุบันของเรา:

• calc.js;
• node_modules;
• operation.js;
• package-lock.json;
• package.json;
• ทดสอบ js;

เรามาจบการทดสอบอ้างอิงครั้งแรกสำหรับโปรแกรมของเรากันเถอะ

การดำเนินการทางคณิตศาสตร์ Dodaemo

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

เริ่มต้นด้วยการพับ ลองเขียนแบบทดสอบซึ่งคำนวณผลรวมของตัวเลขสองตัวโดยไม่ซ้ำกัน ในโค้ดด้านล่าง เราตรวจสอบว่าต้นทุนคือ 1 และ 3 สำหรับฟังก์ชันเพิ่มเติม add() 4:

Const ยืนยัน = ต้องการ ("ยืนยัน"); it("ทราบผลรวมของ 1 และ 3 อย่างถูกต้อง", () => ( assert.equal(add(1, 3), 4); ));

หลังจากที่ฉันรันการทดสอบโดยใช้คำสั่งทดสอบ npm ฉันทำสิ่งนี้:

> mocha 0 ผ่าน (9ms) 1 ล้มเหลว 1) รู้ผลรวม 1 และ 3 อย่างถูกต้อง: ReferenceError: เพิ่มไม่ได้กำหนดไว้ที่ Context.it (test.js:5:16) npm ERR! การทดสอบล้มเหลว ดูรายละเอียดเพิ่มเติม

การทดสอบล้มเหลวด้วย referenceError: ไม่ได้กำหนดการเพิ่ม เราทดสอบฟังก์ชัน add() เนื่องจากไม่มีวิธีอื่น ดังนั้นผลลัพธ์ดังกล่าวจึงค่อนข้างชัดเจน

มาสร้างฟังก์ชัน add() ให้กับไฟล์กันเถอะ operation.js:

Const บวก = (x, y) => (+x) + (+y);

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

หมายเหตุ ที่นี่เราเพิ่มฟังก์ชันลูกศร ES6 และการหมุนโดยปริยาย

เราใช้ Node.js และแยกโค้ดออกเป็นไฟล์ที่ไม่ระบุตัวตน จำเป็นต้องเพิ่มความเร็วให้กับ module.exports เพื่อส่งออกโค้ด:

Const บวก = (x, y) => (+x) + (+y); module.exports = (เพิ่ม)

ด้านบนของไฟล์ ทดสอบ jsเรานำเข้ารหัส z operation.jsสำหรับความช่วยเหลือจากrequire() หากต้องการชนะฟังก์ชันโดยการเปลี่ยนการดำเนินการ คุณต้องจำ add() ไปที่ operation.add() :

การดำเนินการ Const = ต้องการ ("./operations.js"); const ยืนยัน = ต้องการ ("ยืนยัน"); it("ทราบผลรวมของ 1 และ 3 อย่างถูกต้อง", () => ( assert.equal(operations.add(1, 3), 4); ));

มาทำการทดสอบกัน:

การทดสอบ $ npm > mocha ✓ รู้ผลรวม 1 และ 3 อย่างถูกต้อง 1 ผ่าน (8ms)

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

It("รู้ผลรวมของ 1 และ 3 อย่างถูกต้อง", () => ( assert.equal(operations.add(1, 3), 4); )); it("ทราบผลรวม -1 อย่างถูกต้อง -1", () => ( assert.equal(operations.add(-1, -1), -2); )); it("รู้ความแตกต่าง 33 อย่างถูกต้อง 3", () => ( assert.equal(operations.subtract(33, 3), 30); )); it("รู้อย่างถูกต้องว่า tvir 12 และ 12", () => ( assert.equal(operations.multiply(12, 12), 144); )); it("มันถูกต้องที่จะรู้เป็นการส่วนตัว 10 และ 2", () => ( assert.equal(operations.divide(10, 2), 5); ));

ตอนนี้เราสร้างและส่งออกฟังก์ชันทั้งหมดใน ทดสอบ js:

Const บวก = (x, y) => (+x) + (+y); ลบ const = (x, y) => (+x) - (+y); const คูณ = (x, y) => (+x) * (+y); const หาร = (x, y) => (+x) / (+y); module.exports = ( บวก ลบ คูณ หาร )

І เปิดตัวการทดสอบใหม่:

การทดสอบ $ npm > mocha ✓ รู้จำนวน 1 และ 3 อย่างถูกต้อง ✓ รู้จำนวน -1 และ -1 อย่างถูกต้อง ✓ รู้ราคา 33 และ 3 อย่างถูกต้อง ✓ รู้ค่าtvіr 12 และ 12 อย่างถูกต้อง ✓ รู้ค่า 10 และ 2 5 ผ่าน ( 8ms)

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

เราเพิ่มการตรวจสอบ

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

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

จำเป็นต้องเขียนฟังก์ชันที่ด้านหลังศีรษะอย่างที่เราสามารถตรวจสอบได้ chi єแนะนำโดยหมายเลข chi nі ภาคผนวกสามารถใช้กับตัวเลขเท่านั้น ดังนั้นจึงสามารถสรุปได้สามสถานการณ์:

1. แนะนำความผิด - ตัวเลข
2. รายการหนึ่งคือตัวเลข และอีกรายการคือแถว
3. การแนะนำที่ไม่เหมาะสม - แถว

ฟังก์ชัน validateNumbers() จะแทนที่พารามิเตอร์ทั้งสอง ฟังก์ชัน isNaN() จะตรวจสอบว่าพารามิเตอร์ไม่ใช่ตัวเลขหรือไม่ และถ้าไม่ใช่ ก็จะเปลี่ยนเป็นเท็จ มิฉะนั้นจะกลายเป็นจริงซึ่งหมายถึงการตรวจสอบที่สำเร็จ

Const validateNumbers = (x, y) => ( if (isNaN(x) && isNaN(y)) ( return false; ) return true; )

อย่าลืมเพิ่ม validateNumbers ให้กับ module.exports ในไฟล์สุดท้าย ตอนนี้คุณสามารถเรียกใช้การทดสอบใหม่:

การทดสอบ $ npm 1) จดจำการให้อภัยเมื่อหลายแถวแทนที่ตัวเลข ✓ รายงานเกี่ยวกับการให้อภัยเมื่อหลายแถวแทนที่ตัวเลข ✓ สำเร็จเมื่อหลายสตริงแทนที่ตัวเลข 7 ผ่าน (12 มิลลิวินาที) 1 ล้มเหลว 1) รายงานเกี่ยวกับการให้อภัยเมื่อหลายแถวแทนที่ตัวเลข ✓ สำเร็จ: จริง : ข้อผิดพลาดในการยืนยัน: == เท็จ + คาดหวัง - จริง -จริง + เท็จ

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

หากคุณพิจารณาฟังก์ชันของเราอีกครั้ง คุณจะสังเกตเห็นได้ว่า ความไม่พอใจสามารถตั้งค่าพารามิเตอร์เป็น NaN เพื่อให้ฟังก์ชันประเมินเป็นเท็จ หากเราต้องการให้ได้ผลเช่นเดียวกัน หากเราต้องการให้พารามิเตอร์ตัวใดตัวหนึ่งเป็น NaN เราต้องแทนที่ && ด้วย || :

Const validateNumbers = (x, y) => ( if (isNaN(x) || isNaN(y)) ( return false; ) return true; )

หลังจากการเปลี่ยนแปลงเหล่านี้ ให้เรียกใช้การทดสอบ npm อีกครั้ง จากนั้นการทดสอบทั้งหมดจะผ่านสำเร็จ:

✓ เตือนเกี่ยวกับการให้อภัยในกรณีของแถวที่ได้รับชัยชนะให้แทนที่หมายเลข ✓ บอกเกี่ยวกับการให้อภัยในกรณีที่มีชัยชนะสองแถวให้เปลี่ยนหมายเลข ✓ ประสบความสำเร็จในกรณีที่มีชัยชนะสองหมายเลข 8 ผ่าน (9ms)

เราประท้วงการทำงานทั้งหมดของโปรแกรมของเรา ฟังก์ชันชนะการดำเนินการทางคณิตศาสตร์และแก้ไขอินพุตได้สำเร็จ ขั้นตอนสุดท้ายคือการสร้างส่วนต่อประสาน Coristuvach

เราสร้างอินเทอร์เฟซ

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

ในขณะนี้ไฟล์ calc.jsอาจว่างเปล่า ที่นี่และบันทึกโปรแกรมของเรา คุณต้องนำเข้าฟังก์ชันตั้งแต่เริ่มต้น operation.js:

การดำเนินการ Const = ต้องการ ("./operations.js");

อินเตอร์เฟสของ vicorist นั้นใช้ในโมดูล Node.js Readline CLI:

Const readline = ต้องการ ("อ่านบรรทัด");

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

Const rl = readline.createInterface (( อินพุต: process.stdin, เอาต์พุต: process.stdout ));

ประการแรก koristuvach มีความผิดใน bachiti หลังจากเปิดตัวโปรแกรม - มันจำเป็นอย่างยิ่งถึงคำแนะนำว่าจะชนะได้อย่างไร ซึ่งเราเร่งความเร็ว console.log() :

Console.log(` Calc.js คุณได้ป้อนเครื่องคิดเลขบน Node.js! เวอร์ชัน: 1.0.0 แบบทดสอบ: koristuvach จำเป็นต้องป้อนตัวเลขสองตัว จากนั้นเลือกสิ่งที่จะใช้กับตัวเลขเหล่านั้น `);

ขั้นแรก มาดูฟังก์ชันของเครื่องคิดเลขกันก่อน และดูว่า console.log() ทำงานตามที่ต้องการหรือไม่ Mi zrobimo เพื่อให้โปรแกรมแจ้งและทำงานให้เสร็จ สำหรับบางคน ให้เพิ่มการคลิกอย่างรวดเร็วในเมธอด rl.close()

ในการรันโปรแกรม ให้ป้อนโหนดและชื่อไฟล์:

$ node calc.js Calc.js คุณมีเครื่องคิดเลข Node.js แล้ว! เวอร์ชัน: 1.0.0. คำศัพท์: koristuvach จำเป็นต้องป้อนตัวเลขสองตัวจากนั้นเลือกสิ่งที่จะใช้ได้

โปรแกรมแสดงการแจ้งเตือนที่สำคัญจะทำงานให้เสร็จสิ้น ตอนนี้จำเป็นต้องเพิ่มการแนะนำของ coristuvach จำเป็นต้องก้าวไปข้างหน้า: เลือกสองตัวเลขและหนึ่งการดำเนินการ สกินอินพุตจะถูกร้องขอโดยเมธอด rl.question():

Rl.question("ป้อนตัวเลขแรก: ", (x) => ( rl.question("ป้อนตัวเลขอื่น: ", (y) => ( rl.question(` เลือกหนึ่งในการดำเนินการที่จะเกิดขึ้น) ) ( -) หลายรายการ (*) ย่อย (/) ตัวเลือกของคุณ: `, (ตัวเลือก) => ( // rl.close(); )); )); ));

การเปลี่ยน x ความหวังสำหรับหมายเลขแรก y - อื่น และตัวเลือก - การดำเนินการถูกเลือก ตอนนี้โปรแกรมของเรากำลังขอข้อมูล แต่ไม่ทำอะไรจากการรับเงิน

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

ถ้า (!operations.validateNumbers(x, y)) ( console.log("คุณป้อนได้เฉพาะตัวเลขเท่านั้น! โปรดเริ่มโปรแกรมใหม่"); )

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

ถ้า (!operations.validateNumbers(x, y)) ( console.log("คุณสามารถป้อนได้เฉพาะตัวเลข! โปรดรีสตาร์ทโปรแกรม"); ) อื่น ( สวิตช์ (ตัวเลือก) ( กรณี "1": console.log( ` จำนวน $(x) และ $(y) ราคา $(operations.add(x, y)).`), ตัวแบ่ง, กรณี "2": console.log(` ราคาขายปลีก $(x) และ $(y) $ ( operation.subtract(x, y)).`); break; case "4": console.log(`Private $(x) and $(y) private $(operations.divide(x, y)). ` ); break; เริ่มโปรแกรมใหม่และเลือกตัวเลขตั้งแต่ 1 ถึง 4"); break; ) )

หมายเหตุ ฟังก์ชัน console.log() มีสตริงอักขระตัวแทนที่อนุญาตให้มีหลายสตริง

/** * เครื่องคิดเลข Node.js อย่างง่าย ซึ่งเป็นแอปเครื่องคิดเลขชนิดหนึ่งที่ใช้ * อินเทอร์เฟซบรรทัดคำสั่งของ Readline */ การดำเนินการ const = ต้องการ ("./operations.js"); const readline = ต้องการ ("อ่านบรรทัด"); // ชัยชนะ readline เพื่อสร้างอินเตอร์เฟส const rl = readline.createInterface((input: process.stdin, output: process.stdout)); console.log(` Calc.js คุณเปิดเครื่องคิดเลขใน Node.js! เวอร์ชัน: 1.0.0 แบบทดสอบ: คุณต้องป้อนตัวเลขสองตัว จากนั้นเลือกสิ่งที่จะใช้กับตัวเลขเหล่านั้น `); rl.question("ป้อนตัวเลขแรก: ", (x) => ( rl.question("ป้อนตัวเลขอื่น: ", (y) => ( rl.question(` เลือกหนึ่งในการดำเนินการที่จะเกิดขึ้น) ) ( -) การคูณ (*) ส่งแล้ว (/) ตัวเลือกของคุณ: `, (choice) => ( if (!operations.validateNumbers(x, y)) ( console.log("สามารถป้อนได้เฉพาะตัวเลขเท่านั้น! โปรดรีสตาร์ทโปรแกรม) . "); ) อื่น ( switch (choice) ( case "1": console.log(`Amount $(x) and $(y) total $(operations.add(x, y)).`); break; กรณี "2": console.log(`Retail $(x) and $(y) cost $(operations.subtract(x, y)).`); x) and $(y) one $(operations. multiply( x, y)).`), แตก; หาร(x, y)).`); แตก; ;));

ตอนนี้โปรแกรมของเราพร้อมแล้ว ลองพิจารณาหุ่นยนต์โยคะอีกครั้งในที่สุด ป้อน 999 และ 1 และเลือกการดำเนินการที่จะดำเนินการ:

$ node calc.js ป้อนหมายเลขแรก: 999 ป้อนหมายเลขอื่น: 1 ทางเลือกของคุณ: 2 ราคา 999 และ 1 ราคา 998

โปรแกรมทำงานสำเร็จโดยให้ผลลัพธ์ที่ถูกต้อง คุณเขียนเครื่องคิดเลขอย่างง่ายโดยใช้ Node.js และเรียนรู้พื้นฐานของการพัฒนา TDD