นี่เป็นตัวอย่างเล็กน้อยที่แสดงให้เห็นถึงปมปัญหาของฉัน:

var innerLib = require('./path/to/innerLib');

function underTest() {
    return innerLib.doComplexStuff();
}

module.exports = underTest;

ฉันพยายามเขียนการทดสอบหน่วยสำหรับรหัสนี้ ฉันจะเยาะเย้ยความต้องการสำหรับinnerLibโดยไม่ต้องเยาะเย้ยrequireฟังก์ชั่นทั้งหมดได้อย่างไร

ดังนั้นนี่คือฉันพยายามที่จะเยาะเย้ยทั่วโลกrequireและพบว่ามันจะไม่ทำงานแม้จะทำเช่นนั้น:

var path = require('path'),
    vm = require('vm'),
    fs = require('fs'),
    indexPath = path.join(__dirname, './underTest');

var globalRequire = require;

require = function(name) {
    console.log('require: ' + name);
    switch(name) {
        case 'connect':
        case indexPath:
            return globalRequire(name);
            break;
    }
};

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

ตอนนี้คุณสามารถ!

ฉันเผยแพร่proxyquireซึ่งจะดูแลเอาชนะความต้องการทั่วโลกในโมดูลของคุณในขณะที่คุณกำลังทดสอบ

ซึ่งหมายความว่าคุณไม่จำเป็นต้องเปลี่ยนแปลงโค้ดเพื่อฉีด mocks สำหรับโมดูลที่ต้องการ

Proxyquire มี API ที่ง่ายมากซึ่งช่วยให้การแก้ไขโมดูลที่คุณพยายามทดสอบและส่งผ่าน mocks / stubs สำหรับโมดูลที่ต้องการในขั้นตอนเดียว

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

ซึ่งเป็นเหตุผลหลักว่าทำไมฉันสร้าง proxyquire - เพื่อให้การพัฒนาแบบทดสอบจากบนลงล่างโดยไม่ต้องยุ่งยาก

ดูเอกสารและตัวอย่างเพื่อวัดว่าเหมาะสมกับความต้องการของคุณหรือไม่

ตัวเลือกที่ดีกว่าในกรณีนี้คือการจำลองวิธีการของโมดูลที่ได้รับคืน

เพื่อให้ดีขึ้นหรือแย่ลงโมดูล node.js ส่วนใหญ่เป็นซิงเกิลตัน โค้ดสองชิ้นที่ต้องการ () โมดูลเดียวกันได้รับการอ้างอิงเดียวกันกับโมดูลนั้น

คุณสามารถใช้ประโยชน์จากสิ่งนี้และใช้บางอย่างเช่นsinonเพื่อจำลองรายการที่จำเป็น การทดสอบมอคค่าดังนี้:

// in your testfile
var innerLib  = require('./path/to/innerLib');
var underTest = require('./path/to/underTest');
var sinon     = require('sinon');

describe("underTest", function() {
  it("does something", function() {
    sinon.stub(innerLib, 'toCrazyCrap').callsFake(function() {
      // whatever you would like innerLib.toCrazyCrap to do under test
    });

    underTest();

    sinon.assert.calledOnce(innerLib.toCrazyCrap); // sinon assertion

    innerLib.toCrazyCrap.restore(); // restore original functionality
  });
});

Sinon มีการบูรณาการที่ดีกับชัยเพื่อทำการยืนยันและฉันเขียนโมดูลเพื่อรวม Sinon กับมอคค่าเพื่อให้ง่ายต่อการล้างข้อมูลสายลับ / ต้นขั้ว (เพื่อหลีกเลี่ยงการทดสอบมลพิษ)

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

ตัวเลือกอื่นคือการใช้ Jocks mocks ติดตามบนหน้าของพวกเขา

ผมใช้จำลองต้อง ตรวจสอบให้แน่ใจว่าคุณกำหนด mocks ของคุณก่อนrequireโมดูลที่จะทดสอบ

การเยาะเย้ยrequireรู้สึกเหมือนแฮ็คที่น่ารังเกียจสำหรับฉัน โดยส่วนตัวฉันจะพยายามหลีกเลี่ยงมันและสร้างรหัสใหม่เพื่อให้สามารถทดสอบได้มากขึ้น มีวิธีการต่างๆในการจัดการการพึ่งพา

1) ผ่านการอ้างอิงเป็นอาร์กิวเมนต์

function underTest(innerLib) {
    return innerLib.doComplexStuff();
}

สิ่งนี้จะทำให้โค้ดทดสอบได้ในระดับสากล ข้อเสียคือคุณต้องผ่านการอ้างอิงรอบ ๆ ซึ่งจะทำให้โค้ดดูซับซ้อนมากขึ้น

2) ใช้โมดูลเป็นคลาสจากนั้นใช้เมธอด / คุณสมบัติคลาสเพื่อรับการพึ่งพา

(นี่คือตัวอย่างที่วางแผนไว้โดยที่การใช้คลาสไม่สมเหตุสมผล แต่สื่อถึงแนวคิด) (ตัวอย่าง ES6)

const innerLib = require('./path/to/innerLib')

class underTestClass {
    getInnerLib () {
        return innerLib
    }

    underTestMethod () {
        return this.getInnerLib().doComplexStuff()
    }
}

ตอนนี้คุณสามารถ stub getInnerLibวิธีทดสอบโค้ดของคุณได้อย่างง่ายดาย รหัสจะละเอียดยิ่งขึ้น แต่ยังง่ายต่อการทดสอบ

หากคุณเคยใช้การเล่นตลกคุณอาจคุ้นเคยกับคุณสมบัติการล้อเลียนของตลก

การใช้ "jest.mock (... )" คุณสามารถระบุสตริงที่จะเกิดขึ้นในคำสั่ง require ในรหัสของคุณที่ใดที่หนึ่งและเมื่อใดก็ตามที่จำเป็นต้องใช้โมดูลโดยใช้สตริงนั้นจะมีการจำลองวัตถุจำลอง

ตัวอย่างเช่น

jest.mock("firebase-admin", () => {
    const a = require("mocked-version-of-firebase-admin");
    a.someAdditionalMockedMethod = () => {}
    return a;
})

จะแทนที่การนำเข้า / ต้องการทั้งหมดของ "firebase-admin" ด้วยวัตถุที่คุณส่งคืนจากฟังก์ชั่น "โรงงาน" นั้น

คุณสามารถทำได้เมื่อใช้ jest เพราะ jest สร้าง runtime รอบ ๆ โมดูลที่มันรันและ injects ต้องการ "hooked" version ในโมดูล แต่คุณจะไม่สามารถทำได้โดยไม่ล้อเล่น

ฉันพยายามที่จะบรรลุเป้าหมายนี้ด้วย จำลองแต่สำหรับฉันมันไม่ได้ผลกับระดับที่ซ้อนกันในแหล่งที่มาของฉัน มีลักษณะที่ปัญหาต่อไปนี้บน GitHub A: จำลองไม่จำเป็นต้องเรียกว่าเสมอกับมอคค่า

เพื่อแก้ไขปัญหานี้ฉันได้สร้างโมดูล npm สองโมดูลคุณสามารถใช้เพื่อบรรลุสิ่งที่คุณต้องการ

คุณต้องมี babel-plugin หนึ่งตัวและโมดูลผู้เยาะเย้ย

• Babel-ปลั๊กอินจำลองต้อง
• jestlike-เยาะเย้ย

ใน. babelrc ของคุณให้ใช้ปลั๊กอิน babel-plugin-mock-require ด้วยตัวเลือกต่อไปนี้:

...
"plugins": [
        ["babel-plugin-mock-require", { "moduleMocker": "jestlike-mock" }],
        ...
]
...

และในไฟล์ทดสอบของคุณใช้โมดูล jestlike-mock ดังนี้:

import {jestMocker} from "jestlike-mock";
...
jestMocker.mock("firebase-admin", () => {
            const firebase = new (require("firebase-mock").MockFirebaseSdk)();
            ...
            return firebase;
});
...

jestlike-mockโมดูลยังคง Rudimental มากและไม่ได้มีเอกสารจำนวนมาก แต่มีไม่มากทั้งรหัส ฉันขอขอบคุณ PRs ใด ๆ สำหรับชุดคุณลักษณะที่สมบูรณ์ยิ่งขึ้น เป้าหมายคือการสร้างคุณสมบัติ "jest.mock" ใหม่ทั้งหมด

เพื่อดูว่า jest ใช้งานได้อย่างไรในการค้นหาโค้ดในแพ็คเกจ "jest-runtime" ดูhttps://github.com/facebook/jest/blob/master/packages/jest-runtime/src/index.js#L734ยกตัวอย่างเช่นที่นี่พวกเขาสร้าง "automock" ของโมดูล

หวังว่าจะช่วย;)

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

คุณต้องสมมติว่าโค้ดของบุคคลที่สามและ node.js นั้นผ่านการทดสอบเป็นอย่างดี

ฉันคิดว่าคุณจะเห็นกรอบการเยาะเย้ยมาถึงในอนาคตอันใกล้ที่เขียนทับ global.require

หากคุณต้องจำลองการเยาะเย้ยคุณสามารถเปลี่ยนรหัสของคุณเพื่อแสดงขอบเขตแบบแยกส่วนได้

// underTest.js
var innerLib = require('./path/to/innerLib');

function underTest() {
    return innerLib.toCrazyCrap();
}

module.exports = underTest;
module.exports.__module = module;

// test.js
function test() {
    var underTest = require("underTest");
    underTest.__module.innerLib = {
        toCrazyCrap: function() { return true; }
    };
    assert.ok(underTest());
}

ถูกเตือนว่าสิ่งนี้จะถูกเปิดเผย.__moduleใน API ของคุณและโค้ดใด ๆ ที่สามารถเข้าถึงขอบเขตแบบแยกส่วนได้ด้วยตนเอง

คุณสามารถใช้ห้องสมุดการเยาะเย้ย :

describe 'UnderTest', ->
  before ->
    mockery.enable( warnOnUnregistered: false )
    mockery.registerMock('./path/to/innerLib', { doComplexStuff: -> 'Complex result' })
    @underTest = require('./path/to/underTest')

  it 'should compute complex value', ->
    expect(@underTest()).to.eq 'Complex result'

รหัสง่าย ๆ ที่จะจำลองโมดูลสำหรับคนที่อยากรู้อยากเห็น

สังเกตุชิ้นส่วนที่คุณใช้วิธีการrequire.cacheและบันทึกย่อrequire.resolveเนื่องจากนี่เป็นซอสลับ

class MockModules {  
  constructor() {
    this._resolvedPaths = {} 
  }
  add({ path, mock }) {
    const resolvedPath = require.resolve(path)
    this._resolvedPaths[resolvedPath] = true
    require.cache[resolvedPath] = {
      id: resolvedPath,
      file: resolvedPath,
      loaded: true,
      exports: mock
    }
  }
  clear(path) {
    const resolvedPath = require.resolve(path)
    delete this._resolvedPaths[resolvedPath]
    delete require.cache[resolvedPath]
  }
  clearAll() {
    Object.keys(this._resolvedPaths).forEach(resolvedPath =>
      delete require.cache[resolvedPath]
    )
    this._resolvedPaths = {}
  }
}

ใช้เช่น :

describe('#someModuleUsingTheThing', () => {
  const mockModules = new MockModules()
  beforeAll(() => {
    mockModules.add({
      // use the same require path as you normally would
      path: '../theThing',
      // mock return an object with "theThingMethod"
      mock: {
        theThingMethod: () => true
      }
    })
  })
  afterAll(() => {
    mockModules.clearAll()
  })
  it('should do the thing', async () => {
    const someModuleUsingTheThing = require('./someModuleUsingTheThing')
    expect(someModuleUsingTheThing.theThingMethod()).to.equal(true)
  })
})

แต่ ... proxyquire นั้นยอดเยี่ยมมากและคุณควรใช้มัน มันทำให้ความต้องการของคุณแทนที่ภาษาท้องถิ่นเพื่อการทดสอบเท่านั้นและฉันขอแนะนำให้มัน