Làm thế nào để viết một bài kiểm tra dự kiến ​​Lỗi sẽ được ném vào Jasmine?

Tôi đang cố gắng viết một bài kiểm tra cho Khung kiểm tra Jasmine có lỗi. Hiện tại tôi đang sử dụng tích hợp Jasmine Node.js từ GitHub .

Trong mô-đun Node của tôi, tôi có đoạn mã sau:

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

Bây giờ tôi cố gắng viết một bài kiểm tra có lỗi này:

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

Tôi cũng đã thử Error()và một số biến thể khác và không thể tìm ra cách làm cho nó hoạt động.

bạn sẽ chuyển một chức năng vào expect(...)cuộc gọi. Mã bạn có ở đây:

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

đang cố gắng thực sự kêu gọi parser.parse(raw) một nỗ lực để chuyển kết quả vào expect(...),

Thay vào đó, hãy thử sử dụng một hàm ẩn danh:

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

Bạn đang sử dụng:

expect(fn).toThrow(e)

Nhưng nếu bạn có một cái nhìn về nhận xét chức năng (dự kiến ​​là chuỗi):

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

Tôi cho rằng có lẽ bạn nên viết nó như thế này (sử dụng lambda - hàm ẩn danh):

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

Điều này được xác nhận trong ví dụ sau:

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

Douglas Crockford khuyến nghị mạnh mẽ phương pháp này, thay vì sử dụng "throw new Error ()" (cách tạo mẫu):

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

Một giải pháp tao nhã hơn là tạo ra một chức năng ẩn danh, mục đích duy nhất của họ là bọc một bindchức năng khác, là sử dụng chức năng của es5 . Hàm liên kết tạo ra một hàm mới, khi được gọi, có thistừ khóa được đặt thành giá trị được cung cấp, với một chuỗi các đối số đã cho trước bất kỳ được cung cấp nào khi hàm mới được gọi.

Thay vì:

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

Xem xét:

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

Cú pháp liên kết cho phép bạn kiểm tra các hàm với các thisgiá trị khác nhau và theo ý kiến ​​của tôi làm cho bài kiểm tra dễ đọc hơn. Xem thêm: https://stackoverflow.com/a/13233194/1248889

Tôi thay thế trình so khớp toThrow của Jasmine bằng cách sau, cho phép bạn khớp với thuộc tính tên của ngoại lệ hoặc thuộc tính thông báo của nó. Đối với tôi điều này làm cho các bài kiểm tra dễ viết hơn và ít giòn hơn, vì tôi có thể làm như sau:

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

và sau đó kiểm tra với những điều sau đây:

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

Điều này cho phép tôi điều chỉnh thông báo ngoại lệ sau đó mà không phá vỡ các bài kiểm tra, khi điều quan trọng là nó đã ném loại ngoại lệ dự kiến.

Đây là sự thay thế cho toThrow cho phép điều này:

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

Như đã đề cập trước đây, một chức năng cần phải được chuyển đến toThrowvì đó là chức năng bạn mô tả trong bài kiểm tra của mình: "Tôi hy vọng chức năng này sẽ ném x"

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

Nếu sử dụng Jasmine-Matchers, bạn cũng có thể sử dụng một trong những cách sau đây khi chúng phù hợp với tình huống;

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

hoặc là

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

Tôi biết đó là nhiều mã hơn nhưng bạn cũng có thể làm:

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

Dành cho những người yêu thích cà phê

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

Đối với bất kỳ ai vẫn có thể phải đối mặt với vấn đề này, đối với tôi, giải pháp được đăng đã không hoạt động và nó vẫn tiếp tục gây ra lỗi này: Error: Expected function to throw an exception. Sau đó tôi nhận ra rằng chức năng mà tôi dự kiến ​​sẽ đưa ra lỗi là một chức năng không đồng bộ và đang mong đợi lời hứa bị từ chối và sau đó ném lỗi và đó là những gì tôi đã làm trong mã của mình:

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

và đó là những gì tôi đã làm trong bài kiểm tra của mình và nó đã hoạt động:

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