Saya menggunakan mocha untuk menguji unit aplikasi yang ditulis untuk node.js

Saya ingin tahu apakah mungkin untuk menguji fungsi unit yang belum diekspor dalam sebuah modul.

Contoh:

Saya memiliki banyak fungsi yang didefinisikan seperti ini di foobar.js

function private_foobar1(){
    ...
}

function private_foobar2(){
    ...
}

dan beberapa fungsi yang diekspor sebagai publik:

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

Test case disusun sebagai berikut:

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

Jelas ini tidak berfungsi, karena private_foobar1tidak diekspor.

Apa cara yang benar untuk menguji metode pribadi unit? Apakah moka memiliki beberapa metode bawaan untuk melakukan itu?

Jika fungsi tidak diekspor oleh modul, itu tidak dapat dipanggil dengan kode uji di luar modul. Itu karena cara kerja JavaScript, dan Mocha tidak dapat dengan sendirinya mengelak dari ini.

Dalam beberapa kasus di mana saya menentukan bahwa pengujian fungsi pribadi adalah hal yang benar untuk dilakukan, apa yang telah saya lakukan adalah mengatur beberapa variabel lingkungan yang diperiksa modul saya untuk menentukan apakah itu berjalan dalam pengaturan pengujian atau tidak. Jika itu berjalan dalam pengaturan pengujian, maka itu mengekspor fungsi tambahan yang kemudian dapat saya panggil selama pengujian.

Kata "lingkungan" digunakan secara longgar di sini. Ini mungkin berarti memeriksa process.envatau sesuatu yang lain yang dapat berkomunikasi dengan modul "Anda sedang diuji sekarang". Contoh di mana saya harus melakukan ini berada dalam lingkungan RequireJS, dan saya telah menggunakan module.configuntuk tujuan ini.

Lihat modul rewire . Ini memungkinkan Anda untuk mendapatkan (dan memanipulasi) variabel dan fungsi pribadi dalam suatu modul.

Jadi dalam kasus Anda penggunaannya akan seperti:

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

Berikut ini adalah alur kerja yang sangat bagus untuk menguji metode pribadi Anda yang dijelaskan oleh Philip Walton, seorang insinyur Google di blog-nya.

Prinsip

• Tulis kode Anda secara normal
• Bind metode pribadi Anda ke objek dalam blok kode terpisah, tandai dengan sebagai _contoh
• Kelilingi blok kode itu dengan memulai dan mengakhiri komentar

Kemudian gunakan tugas build atau sistem build Anda sendiri (untuk contoh grunt-strip-code) untuk menghapus blok ini untuk build produksi.

Build pengujian Anda memiliki akses ke api pribadi Anda, dan build produksi Anda belum.

Potongan

Tulis kode Anda seperti ini:

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

Dan tugas kasarmu seperti itu

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

Lebih dalam

Dalam artikel selanjutnya , ini menjelaskan "mengapa" dari "pengujian metode pribadi"

Jika Anda lebih suka membuatnya sederhana, cukup ekspor anggota pribadi juga, tetapi jelas dipisahkan dari API publik dengan beberapa konvensi, misalnya awali mereka dengan _atau sarang mereka di bawah satu objek pribadi .

var privateWorker = function() {
    return 1
}

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

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

Saya membuat paket npm untuk tujuan ini yang mungkin berguna bagi Anda: memerlukan-dari

Pada dasarnya Anda mengekspos metode non-publik dengan:

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

catatan: testExports dapat berupa nama valid yang Anda inginkan, kecuali exportstentu saja.

Dan dari modul lain:

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

Saya telah menambahkan fungsi tambahan yang saya beri nama Internal () dan mengembalikan semua fungsi pribadi dari sana. Ini internal () function kemudian diekspor. Contoh:

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

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

Anda dapat memanggil fungsi internal seperti ini:

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

Saya suka solusi ini karena:

• hanya satu fungsi Internal () yang selalu diekspor. Ini internal () fungsi selalu digunakan untuk menguji fungsi-fungsi pribadi.
• Sederhana untuk diterapkan
• Dampak rendah pada kode produksi (hanya satu fungsi tambahan)

Saya mengikuti jawaban @barwin dan memeriksa bagaimana tes unit dapat dilakukan dengan modul rewire . Saya dapat mengkonfirmasi bahwa solusi ini hanya berfungsi.

Modul harus diminta dalam dua bagian - bagian publik dan bagian pribadi. Untuk fungsi publik, Anda dapat melakukannya dengan cara standar:

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

Untuk ruang lingkup pribadi:

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

Untuk mengetahui lebih banyak tentang subjek, saya membuat contoh kerja dengan pengujian modul lengkap, pengujian mencakup ruang lingkup pribadi dan publik.

Untuk informasi lebih lanjut, saya mendorong Anda untuk memeriksa artikel ( https://medium.com/@macsikora/how-to-test-private-functions-of-es6-module-fb8c1345b25f ) yang sepenuhnya menggambarkan subjek, termasuk contoh kode.

Saya tahu bahwa ini belum tentu jawaban yang Anda cari, tetapi apa yang saya temukan adalah bahwa sebagian besar waktu jika fungsi pribadi layak diuji, ada baiknya berada di file sendiri.

Misalnya alih-alih memiliki metode pribadi dalam file yang sama dengan yang publik, seperti ini ...

src / hal / 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);
}

... Anda membaginya seperti ini:

src / hal / 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 / hal / internal / helper1.js

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

src / hal / internal / helper2.js

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

Dengan begitu, Anda dapat dengan mudah menguji helper1dan helper2apa adanya, tanpa menggunakan Rewire dan "sihir" lainnya (yang, saya temukan, memiliki poin rasa sakitnya sendiri saat debugging, atau ketika Anda mencoba untuk bergerak menuju TypeScript, belum lagi lebih miskin dimengerti untuk kolega baru). Dan mereka yang berada di sub-folder bernama internal, atau sesuatu seperti itu, akan membantu menghindari penggunaan mereka secara tidak sengaja di tempat yang tidak diinginkan.

PS: Masalah umum lainnya dengan metode "pribadi" adalah bahwa jika Anda ingin menguji publicMethod1dan publicMethod2dan mengejek pembantu, sekali lagi, Anda biasanya perlu sesuatu seperti Rewire untuk melakukan itu. Namun, jika mereka berada di file terpisah, Anda dapat menggunakan Proxyquire untuk melakukannya, yang, tidak seperti Rewire, tidak memerlukan perubahan apa pun pada proses pembuatan Anda, mudah dibaca dan di-debug, dan berfungsi dengan baik bahkan dengan TypeScript.

Untuk membuat metode pribadi tersedia untuk pengujian, saya melakukan ini:

const _myPrivateMethod: () => {};

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

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

module.exports = methods;