ฉันใช้มอคค่าเพื่อทดสอบหน่วยแอปพลิเคชันที่เขียนขึ้นสำหรับ node.js

ฉันสงสัยว่าเป็นไปได้ไหมที่จะใช้ฟังก์ชันทดสอบหน่วยที่ยังไม่ได้ส่งออกในโมดูล

ตัวอย่าง:

ฉันมีฟังก์ชันมากมายที่กำหนดไว้เช่นนี้ใน foobar.js

function private_foobar1(){
    ...
}

function private_foobar2(){
    ...
}

และฟังก์ชันบางอย่างที่ส่งออกเป็นสาธารณะ:

exports.public_foobar3 = function(){
    ...
}

กรณีทดสอบมีโครงสร้างดังนี้:

describe("private_foobar1", function() {
    it("should do stuff", function(done) {
        var stuff = foobar.private_foobar1(filter);
        should(stuff).be.ok;
        should(stuff).....

เห็นได้ชัดว่าสิ่งนี้ใช้ไม่ได้เนื่องจากprivate_foobar1ไม่มีการส่งออก

วิธีที่ถูกต้องในการทดสอบหน่วยส่วนตัวคืออะไร? มอคค่ามีวิธีการในตัวสำหรับการทำเช่นนั้นหรือไม่?

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

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

คำว่า "สิ่งแวดล้อม" ถูกนำมาใช้อย่างหลวม ๆ ในที่นี้ อาจหมายถึงการตรวจสอบprocess.envหรืออย่างอื่นที่สามารถสื่อสารกับโมดูล "คุณกำลังทดสอบอยู่" อินสแตนซ์ที่ฉันต้องทำสิ่งนี้อยู่ในสภาพแวดล้อม RequireJS และฉันใช้module.configเพื่อจุดประสงค์นี้

ตรวจสอบโมดูลrewire ช่วยให้คุณได้รับ (และจัดการ) ตัวแปรและฟังก์ชันส่วนตัวภายในโมดูล

ดังนั้นในกรณีของคุณการใช้งานจะเป็นดังนี้:

var rewire = require('rewire'),
    foobar = rewire('./foobar'); // Bring your module in with rewire

describe("private_foobar1", function() {

    // Use the special '__get__' accessor to get your private function.
    var private_foobar1 = foobar.__get__('private_foobar1');

    it("should do stuff", function(done) {
        var stuff = private_foobar1(filter);
        should(stuff).be.ok;
        should(stuff).....

นี่คือขั้นตอนการทำงานที่ดีมากในการทดสอบวิธีการส่วนตัวของคุณซึ่งอธิบายโดย Philip Walton วิศวกรของ Google ในบล็อก

หลัก

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

จากนั้นใช้งานการสร้างหรือระบบการสร้างของคุณเอง (สำหรับตัวอย่างรหัสคำราม) เพื่อดึงกลุ่มนี้ออกเพื่อสร้างงานสร้าง

การทดสอบของคุณสามารถเข้าถึง API ส่วนตัวของคุณได้

เศษเล็กเศษน้อย

เขียนรหัสของคุณดังนี้:

var myModule = (function() {

  function foo() {
    // private function `foo` inside closure
    return "foo"
  }

  var api = {
    bar: function() {
      // public function `bar` returned from closure
      return "bar"
    }
  }

  /* test-code */
  api._foo = foo
  /* end-test-code */

  return api
}())

และงานที่หนักอึ้งของคุณเช่นนั้น

grunt.registerTask("test", [
  "concat",
  "jshint",
  "jasmine"
])
grunt.registerTask("deploy", [
  "concat",
  "strip-code",
  "jshint",
  "uglify"
])

ลึกมากขึ้น

ในบทความต่อมาจะอธิบายถึง "ทำไม" ของ "การทดสอบวิธีส่วนตัว"

หากคุณต้องการให้มันง่ายเพียงแค่ส่งออกสมาชิกส่วนตัวเช่นกัน แต่แยกออกจาก API สาธารณะอย่างชัดเจนด้วยหลักการบางอย่างเช่นนำหน้าด้วย _หรือซ้อนไว้ภายใต้วัตถุส่วนตัวเดียว

var privateWorker = function() {
    return 1
}

var doSomething = function() {
    return privateWorker()
}

module.exports = {
    doSomething: doSomething,
    _privateWorker: privateWorker
}

ฉันสร้างแพ็คเกจ npm เพื่อจุดประสงค์นี้ซึ่งคุณอาจพบว่ามีประโยชน์: ต้องใช้จาก

โดยทั่วไปคุณเปิดเผยวิธีการที่ไม่ใช่สาธารณะโดย:

module.testExports = {
    private_foobar1: private_foobar1,
    private_foobar2: private_foobar2,
    ...
}

หมายเหตุ: testExportsสามารถเป็นชื่อที่ถูกต้องที่คุณต้องการยกเว้นexportsแน่นอน

และจากโมดูลอื่น:

var requireFrom = require('require-from');
var private_foobar1 = requireFrom('testExports', './path-to-module').private_foobar1;

ฉันได้เพิ่มฟังก์ชันพิเศษที่ฉันชื่อInternal ()และส่งคืนฟังก์ชันส่วนตัวทั้งหมดจากที่นั่น นี้ภายใน ()ฟังก์ชั่นการส่งออกแล้ว ตัวอย่าง:

function Internal () {
  return { Private_Function1, Private_Function2, Private_Function2}
}

// Exports --------------------------
module.exports = { PublicFunction1, PublicFunction2, Internal }

คุณสามารถเรียกใช้ฟังก์ชันภายในดังนี้:

let test = require('.....')
test.Internal().Private_Function1()

ฉันชอบวิธีนี้มากที่สุดเพราะ:

• เพียงฟังก์ชันเดียวเท่านั้นภายใน ()จะถูกส่งออกเสมอ นี้ภายใน ()ฟังก์ชั่นนั้นจะใช้ในการทดสอบฟังก์ชั่นส่วนตัว
• ใช้งานง่าย
• ผลกระทบต่ำต่อรหัสการผลิต (มีฟังก์ชันพิเศษเพียงฟังก์ชันเดียว)

ฉันติดตามคำตอบของ@barwinและตรวจสอบวิธีการทดสอบหน่วยด้วยrewireโมดูลฉันสามารถยืนยันได้ว่าโซลูชันนี้ใช้งานได้จริง

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

const { public_foobar3 } = require('./foobar');

สำหรับขอบเขตส่วนตัว:

const privateFoobar = require('rewire')('./foobar');
const private_foobar1 = privateFoobar .__get__('private_foobar1');
const private_foobar2 = privateFoobar .__get__('private_foobar2');

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

สำหรับข้อมูลเพิ่มเติมฉันขอแนะนำให้คุณตรวจสอบบทความ ( https://medium.com/@macsikora/how-to-test-private-functions-of-es6-module-fb8c1345b25f ) ที่อธิบายเรื่องนี้อย่างครบถ้วนซึ่งจะมีตัวอย่างโค้ดด้วย

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

เช่นแทนที่จะมีเมธอดส่วนตัวในไฟล์เดียวกับแบบสาธารณะเช่นนี้ ...

src / สิ่ง / PublicInterface.js

function helper1 (x) {
    return 2 * x;
}

function helper2 (x) {
    return 3 * x;
}

export function publicMethod1(x) {
    return helper1(x);
}

export function publicMethod2(x) {
    return helper1(x) + helper2(x);
}

... คุณแยกออกเป็นดังนี้:

src / สิ่ง / PublicInterface.js

import {helper1} from './internal/helper1.js';
import {helper2} from './internal/helper2.js';

export function publicMethod1(x) {
    return helper1(x);
}

export function publicMethod2(x) {
    return helper1(x) + helper2(x);
}

src / สิ่งภายใน / / helper1.js

export function helper1 (x) {
    return 2 * x;
}

src / สิ่งภายใน / / helper2.js

export function helper2 (x) {
    return 3 * x;
}

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

PS: อีกปัญหาที่พบด้วยวิธีการ "เอกชน" คือว่าถ้าคุณต้องการที่จะทดสอบpublicMethod1และpublicMethod2และเยาะเย้ยผู้ช่วยเหลืออีกครั้งคุณจำเป็นบางอย่างเช่น rewire จะทำเช่นนั้นได้ตามปกติ อย่างไรก็ตามหากไฟล์เหล่านี้อยู่ในไฟล์แยกกันคุณสามารถใช้Proxyquireเพื่อทำสิ่งนี้ได้ซึ่งไม่เหมือนกับ Rewire ที่ไม่ต้องการการเปลี่ยนแปลงใด ๆ ในกระบวนการสร้างของคุณอ่านและแก้ไขจุดบกพร่องได้ง่ายและทำงานได้ดีแม้กับ TypeScript

เพื่อให้มีวิธีการส่วนตัวสำหรับการทดสอบฉันทำสิ่งนี้:

const _myPrivateMethod: () => {};

const methods = {
    myPublicMethod1: () => {},
    myPublicMethod2: () => {},
}

if (process.env.NODE_ENV === 'test') {
    methods._myPrivateMethod = _myPrivateMethod;
}

module.exports = methods;