Bagaimana cara menulis tes yang mengharapkan Kesalahan dilemparkan ke Jasmine?

Saya mencoba menulis tes untuk Jasmine Test Framework yang mengharapkan kesalahan. Saat ini saya menggunakan integrasi Jasmine Node.js dari GitHub .

Dalam modul Node saya, saya memiliki kode berikut:

throw new Error("Parsing is not possible");

Sekarang saya mencoba menulis tes yang mengharapkan kesalahan ini:

describe('my suite...', function() {
    [..]
    it('should not parse foo', function() {
    [..]
        expect(parser.parse(raw)).toThrow(new Error("Parsing is not possible"));
    });
});

Saya juga mencoba Error()dan beberapa varian lainnya dan tidak tahu cara membuatnya bekerja.

Anda harus menyampaikan fungsi ke dalam expect(...)panggilan. Kode yang Anda miliki di sini:

// incorrect:
expect(parser.parse(raw)).toThrow(new Error("Parsing is not possible"));

sedang mencoba untuk benar-benar memanggil parser.parse(raw) upaya untuk meneruskan hasilnya expect(...),

Coba gunakan fungsi anonim:

expect( function(){ parser.parse(raw); } ).toThrow(new Error("Parsing is not possible"));

Anda menggunakan:

expect(fn).toThrow(e)

Tetapi jika Anda akan melihat komentar fungsi (yang diharapkan adalah string):

294 /**
295  * Matcher that checks that the expected exception was thrown by the actual.
296  *
297  * @param {String} expected
298  */
299 jasmine.Matchers.prototype.toThrow = function(expected) {

Saya kira Anda mungkin harus menulis seperti ini (menggunakan lambda - fungsi anonim):

expect(function() { parser.parse(raw); } ).toThrow("Parsing is not possible");

Ini dikonfirmasi dalam contoh berikut:

expect(function () {throw new Error("Parsing is not possible")}).toThrow("Parsing is not possible");

Douglas Crockford sangat merekomendasikan pendekatan ini, daripada menggunakan "throw new Error ()" (cara prototyping):

throw {
   name: "Error",
   message: "Parsing is not possible"
}

Solusi yang lebih elegan daripada membuat fungsi anonim yang tujuan utamanya adalah untuk membungkus yang lain, adalah menggunakan bindfungsi es5 . Fungsi bind menciptakan fungsi baru yang, ketika dipanggil, memiliki thiskata kunci yang disetel ke nilai yang disediakan, dengan urutan argumen tertentu sebelum yang disediakan ketika fungsi baru dipanggil.

Dari pada:

expect(function () { parser.parse(raw, config); } ).toThrow("Parsing is not possible");

Mempertimbangkan:

expect(parser.parse.bind(parser, raw, config)).toThrow("Parsing is not possible");

Sintaks mengikat memungkinkan Anda untuk menguji fungsi dengan thisnilai yang berbeda , dan menurut saya membuat tes lebih mudah dibaca. Lihat juga: https://stackoverflow.com/a/13233194/1248889

Saya mengganti korek api toThrow Jasmine dengan yang berikut, yang memungkinkan Anda mencocokkan pada properti nama pengecualian atau properti pesannya. Bagi saya ini membuat tes lebih mudah untuk ditulis dan kurang rapuh, karena saya dapat melakukan hal berikut:

throw {
   name: "NoActionProvided",
   message: "Please specify an 'action' property when configuring the action map."
}

dan kemudian uji dengan yang berikut ini:

expect (function () {
   .. do something
}).toThrow ("NoActionProvided");

Ini memungkinkan saya mengubah pesan pengecualian nanti tanpa melanggar tes, ketika yang penting adalah bahwa itu melemparkan jenis pengecualian yang diharapkan.

Ini adalah pengganti toThrow yang memungkinkan ini:

jasmine.Matchers.prototype.toThrow = function(expected) {
  var result = false;
  var exception;
  if (typeof this.actual != 'function') {
    throw new Error('Actual is not a function');
  }
  try {
    this.actual();
  } catch (e) {
    exception = e;
  }
  if (exception) {
      result = (expected === jasmine.undefined || this.env.equals_(exception.message || exception, expected.message || expected) || this.env.equals_(exception.name, expected));
  }

  var not = this.isNot ? "not " : "";

  this.message = function() {
    if (exception && (expected === jasmine.undefined || !this.env.equals_(exception.message || exception, expected.message || expected))) {
      return ["Expected function " + not + "to throw", expected ? expected.name || expected.message || expected : " an exception", ", but it threw", exception.name || exception.message || exception].join(' ');
    } else {
      return "Expected function to throw an exception.";
    }
  };

  return result;
};

Seperti yang disebutkan sebelumnya, fungsi harus dilewatkan toThrowkarena fungsi yang Anda jelaskan dalam pengujian Anda: "Saya berharap fungsi ini untuk membuang x"

expect(() => parser.parse(raw))
  .toThrow(new Error('Parsing is not possible'));

Jika menggunakan Jasmine-Matchers Anda juga dapat menggunakan salah satu dari berikut ini ketika mereka sesuai dengan situasi;

// I just want to know that an error was
// thrown and nothing more about it
expect(() => parser.parse(raw))
  .toThrowAnyError();

atau

// I just want to know that an error of 
// a given type was thrown and nothing more
expect(() => parser.parse(raw))
  .toThrowErrorOfType(TypeError);

Saya tahu ini lebih banyak kode tetapi Anda juga dapat melakukannya:

try
   do something
   @fail Error("should send a Exception")
 catch e
   expect(e.name).toBe "BLA_ERROR"
   expect(e.message).toBe 'Message'

Untuk pecinta kopi

expect( => someMethodCall(arg1, arg2)).toThrow()

Bagi siapa pun yang mungkin masih menghadapi masalah ini, bagi saya solusi yang diposting tidak bekerja dan terus melempar kesalahan ini: Error: Expected function to throw an exception. Saya kemudian menyadari bahwa fungsi yang saya harapkan untuk melakukan kesalahan adalah fungsi async dan mengharapkan janji untuk ditolak dan kemudian buang kesalahan dan itulah yang saya lakukan dalam kode saya:

throw new Error('REQUEST ID NOT FOUND');

dan itulah yang saya lakukan dalam pengujian dan berhasil:

it('Test should throw error if request not found', willResolve(() => {
         const promise = service.getRequestStatus('request-id');
                return expectToReject(promise).then((err) => {
                    expect(err.message).toEqual('REQUEST NOT FOUND');
                });
            }));