จะเขียนแบบทดสอบที่คาดว่าจะเกิดข้อผิดพลาดในจัสมินได้อย่างไร?

ฉันพยายามเขียนการทดสอบสำหรับกรอบการทดสอบจัสมินซึ่งคาดว่าจะเกิดข้อผิดพลาด ในขณะที่ฉันใช้บูรณาจัสมิน Node.js จาก GitHub

ในโมดูลโหนดของฉันฉันมีรหัสต่อไปนี้:

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

ตอนนี้ฉันพยายามเขียนการทดสอบที่คาดว่าจะเกิดข้อผิดพลาดนี้:

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

ฉันพยายามError()และตัวแปรอื่น ๆ และไม่สามารถหาวิธีทำให้มันใช้งานได้

คุณควรจะผ่านฟังก์ชั่นในการexpect(...)โทร รหัสที่คุณมีที่นี่:

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

พยายามที่จะจริงโทร parser.parse(raw)ในความพยายามที่จะผ่านเข้าไปในผลexpect(...),

ลองใช้ฟังก์ชันที่ไม่ระบุชื่อแทน:

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

คุณกำลังใช้:

expect(fn).toThrow(e)

แต่ถ้าคุณจะได้ดูความคิดเห็นของฟังก์ชั่น (คาดว่าจะเป็นสตริง):

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

ฉันคิดว่าคุณน่าจะเขียนแบบนี้ (ใช้แลมบ์ดา - ฟังก์ชั่นนิรนาม):

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

นี่คือการยืนยันในตัวอย่างต่อไปนี้:

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

Douglas Crockford แนะนำวิธีนี้อย่างยิ่งแทนที่จะใช้ "throw new Error ()" (วิธีการสร้างต้นแบบ):

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

โซลูชันที่สง่างามกว่าการสร้างฟังก์ชั่นนิรนามซึ่งมีจุดประสงค์เดียวคือห่อคำอื่นให้ใช้bindฟังก์ชั่นของ es5 ฟังก์ชั่นผูกสร้างฟังก์ชั่นใหม่ที่เมื่อเรียกว่ามีการthisตั้งค่าคำหลักเป็นค่าที่ให้ไว้กับลำดับของข้อโต้แย้งที่กำหนดก่อนหน้าใด ๆ ที่มีให้เมื่อมีการเรียกใช้ฟังก์ชั่นใหม่

แทน:

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

พิจารณา:

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

ไวยากรณ์ผูกช่วยให้คุณสามารถทดสอบฟังก์ชั่นที่มีthisค่าที่แตกต่างกันและในความคิดของฉันทำให้การทดสอบอ่านง่ายขึ้น ดูเพิ่มเติมที่: https://stackoverflow.com/a/13233194/1248889

ฉันแทนที่การจับคู่ toThrow ของจัสมินด้วยสิ่งต่อไปนี้ซึ่งช่วยให้คุณจับคู่กับคุณสมบัติชื่อข้อยกเว้นหรือคุณสมบัติข้อความ สำหรับฉันนี่ทำให้การทดสอบง่ายขึ้นในการเขียนและเปราะน้อยลงเนื่องจากฉันสามารถทำสิ่งต่อไปนี้:

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

จากนั้นทดสอบด้วยสิ่งต่อไปนี้:

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

สิ่งนี้ช่วยให้ฉันปรับแต่งข้อความข้อยกเว้นในภายหลังโดยไม่ทำลายการทดสอบเมื่อสิ่งสำคัญคือมันโยนประเภทข้อยกเว้นที่คาดไว้

นี่คือการแทนที่ toThrow ที่อนุญาตสิ่งนี้:

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;
};

ดังกล่าวก่อนหน้านี้ฟังก์ชั่นจะต้องผ่านไปtoThrowเพราะมันเป็นฟังก์ชั่นที่คุณอธิบายในการทดสอบของคุณ: "ฉันคาดหวังว่าฟังก์ชั่นนี้จะโยน x"

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

หากใช้Jasmine-Matchersคุณสามารถใช้ข้อใดข้อหนึ่งต่อไปนี้เมื่อพวกเขาเหมาะสมกับสถานการณ์

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

หรือ

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

ฉันรู้ว่าเป็นรหัสเพิ่มเติม แต่คุณสามารถทำได้:

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

สำหรับคนรักกาแฟ

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

สำหรับทุกคนที่ยังอาจประสบปัญหานี้สำหรับฉันวิธีการโพสต์ไม่ทำงานและมันยังคงทิ้งข้อผิดพลาดนี้: Error: Expected function to throw an exception. ฉันรู้ในภายหลังว่าฟังก์ชั่นที่ฉันคาดว่าจะโยนข้อผิดพลาดเป็นฟังก์ชั่น async และคาดว่าจะสัญญา ถูกปฏิเสธแล้วโยนข้อผิดพลาดและนั่นคือสิ่งที่ฉันทำในรหัสของฉัน:

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

และนั่นคือสิ่งที่ฉันทำในการทดสอบและได้ผล:

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');
                });
            }));