Tôi đang sử dụng mocha để kiểm tra đơn vị một ứng dụng được viết cho node.js

Tôi tự hỏi nếu nó có thể đơn vị chức năng kiểm tra chưa được xuất khẩu trong một mô-đun.

Thí dụ:

Tôi có rất nhiều hàm được định nghĩa như thế này trong foobar.js

function private_foobar1(){
    ...
}

function private_foobar2(){
    ...
}

và một vài chức năng được xuất dưới dạng công khai:

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

Trường hợp thử nghiệm được cấu trúc như sau:

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

Rõ ràng điều này không hoạt động, vì private_foobar1không được xuất khẩu.

Cách chính xác để kiểm tra đơn vị phương pháp riêng là gì? Có mocha có một số phương pháp tích hợp để làm điều đó?

Nếu chức năng không được mô-đun xuất ra, nó không thể được gọi bằng mã kiểm tra bên ngoài mô-đun. Đó là do cách JavaScript hoạt động và Mocha không thể tự mình phá vỡ điều này.

Trong một số trường hợp tôi xác định rằng kiểm tra một chức năng riêng tư là điều nên làm, điều tôi đã làm là đặt một số biến môi trường mà mô-đun của tôi kiểm tra để xác định xem nó có chạy trong thiết lập thử nghiệm hay không. Nếu nó chạy trong thiết lập thử nghiệm, thì nó sẽ xuất các chức năng bổ sung mà sau đó tôi có thể gọi trong khi thử nghiệm.

Từ "môi trường" được sử dụng một cách lỏng lẻo ở đây. Nó có thể có nghĩa là kiểm tra process.envhoặc một cái gì đó khác có thể giao tiếp với mô-đun "bạn đang được thử nghiệm ngay bây giờ". Các trường hợp tôi phải làm điều này là trong môi trường RequireJS và tôi đã sử dụng module.configcho mục đích này.

Kiểm tra các mô-đun tua lại . Nó cho phép bạn có được (và thao tác) các biến và hàm riêng trong một mô-đun.

Vì vậy, trong trường hợp của bạn, việc sử dụng sẽ là một cái gì đó như:

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).....

Đây là một quy trình làm việc thực sự tốt để kiểm tra các phương pháp riêng tư của bạn được giải thích bởi Philip Walton, một kỹ sư của Google trên blog của mình.

Nguyên tắc

• Viết mã của bạn bình thường
• Liên kết các phương thức riêng tư của bạn với đối tượng trong một khối mã riêng biệt, đánh dấu nó bằng một _ví dụ
• Bao quanh khối mã đó bằng cách bắt đầu và kết thúc nhận xét

Sau đó, sử dụng một tác vụ xây dựng hoặc hệ thống xây dựng của riêng bạn (ví dụ mã grunt-dải mã) để loại bỏ khối này cho các bản dựng sản xuất.

Bản dựng thử nghiệm của bạn có quyền truy cập vào api riêng của bạn và bản dựng sản xuất của bạn thì không.

Đoạn trích

Viết mã của bạn như thế này:

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
}())

Và những nhiệm vụ khó khăn của bạn như thế

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

Sau hon

Trong một bài viết sau , nó giải thích "tại sao" của "thử nghiệm các phương thức riêng tư"

Nếu bạn muốn giữ cho nó đơn giản, chỉ cần xuất các thành viên riêng tư, nhưng tách biệt rõ ràng với API công khai với một số quy ước, ví dụ: tiền tố chúng với một _hoặc lồng chúng dưới một đối tượng riêng tư .

var privateWorker = function() {
    return 1
}

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

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

Tôi đã thực hiện một gói npm cho mục đích này mà bạn có thể thấy hữu ích: request-from

Về cơ bản, bạn phơi bày các phương pháp không công khai bằng cách:

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

lưu ý: testExports có thể là bất kỳ tên hợp lệ nào bạn muốn, ngoại trừ exportstất nhiên.

Và từ một mô-đun khác:

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

Tôi đã thêm một hàm bổ sung mà tôi đặt tên là Internal () và trả về tất cả các hàm riêng tư từ đó. Hàm Internal () này sau đó được xuất. Thí dụ:

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

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

Bạn có thể gọi các chức năng nội bộ như thế này:

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

Tôi thích giải pháp này nhất vì:

• chỉ có một hàm Internal () luôn được xuất. Hàm Internal () này luôn được sử dụng để kiểm tra các hàm riêng.
• Thật đơn giản để thực hiện
• Tác động thấp đến mã sản xuất (chỉ có một chức năng bổ sung)

Tôi đã làm theo câu trả lời của @barwin và kiểm tra cách kiểm tra đơn vị có thể được thực hiện với mô đun tua lại . Tôi có thể xác nhận rằng giải pháp này chỉ đơn giản là hoạt động.

Các mô-đun nên được yêu cầu trong hai phần - một phần công cộng và một phần riêng tư. Đối với các chức năng công cộng, bạn có thể làm điều đó theo cách tiêu chuẩn:

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

Đối với phạm vi riêng tư:

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

Để biết thêm về chủ đề này, tôi đã tạo một ví dụ hoạt động với thử nghiệm mô-đun đầy đủ, thử nghiệm bao gồm phạm vi riêng tư và công khai.

Để biết thêm thông tin, tôi khuyến khích bạn kiểm tra bài viết ( https://medium.com/@macsikora/how-to-test-private-fifts-of-es6-module-fb8c1345b25f ) mô tả đầy đủ chủ đề, nó bao gồm các mẫu mã.

Tôi biết rằng đây không nhất thiết là câu trả lời mà bạn đang tìm kiếm, nhưng điều tôi đã tìm thấy là hầu hết thời gian nếu một chức năng riêng tư đáng để thử nghiệm, nó đáng để nằm trong tệp riêng của nó.

Ví dụ, thay vì có các phương thức riêng tư trong cùng một tệp với các phương thức công khai, như thế này ...

src / điều / 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);
}

... bạn chia nó ra như thế này:

src / điều / 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 / điều / nội bộ / helper1.js

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

src / điều / nội bộ / helper2.js

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

Bằng cách đó, bạn có thể dễ dàng kiểm tra helper1và thực tế helper2, mà không cần sử dụng Rewire và "ma thuật" khác (mà tôi đã tìm thấy, có những điểm đau riêng trong khi gỡ lỗi hoặc khi bạn cố gắng tiến về TypeScript, không đề cập đến việc kém hơn dễ hiểu cho đồng nghiệp mới). Và chúng nằm trong một thư mục con được gọi internal, hoặc một cái gì đó tương tự, sẽ giúp tránh việc sử dụng chúng vô tình ở những nơi ngoài ý muốn.

PS: Một vấn đề thường gặp với các phương pháp "tư nhân" ở đây là nếu bạn muốn thử nghiệm publicMethod1và publicMethod2và nhạo báng những người giúp việc, một lần nữa, bạn thường cần một cái gì đó giống như ReWire để làm điều đó. Tuy nhiên, nếu chúng nằm trong các tệp riêng biệt, bạn có thể sử dụng Proxyquire để thực hiện, không giống như Rewire, không cần bất kỳ thay đổi nào đối với quy trình xây dựng của bạn, dễ đọc và gỡ lỗi và hoạt động tốt ngay cả với TypeScript.

Để làm cho các phương thức riêng tư có sẵn để thử nghiệm, tôi làm điều này:

const _myPrivateMethod: () => {};

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

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

module.exports = methods;