Yasemin'de bir hata atılmasını bekleyen bir test nasıl yazılır?

Bir hata bekliyor Jasmine Test Framework için bir test yazmaya çalışıyorum . Şu anda GitHub'dan bir Jasmine Node.js entegrasyonu kullanıyorum .

Düğüm modülümde şu kod var:

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

Şimdi bu hatayı bekleyen bir test yazmaya çalışıyorum:

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

Ayrıca Error()ve diğer bazı varyantları denedim ve nasıl çalıştığını anlayamıyorum.

expect(...)çağrıya bir fonksiyon geçiriyor olmalısınız . Burada sahip olduğunuz kod:

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

aslında çalışıyor çağrı parser.parse(raw) içine geçmesi sonucunu bir girişim expect(...),

Bunun yerine anonim bir işlev kullanmayı deneyin:

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

Kullanıyorsun:

expect(fn).toThrow(e)

Ancak işlev yorumuna bir göz atacaksanız (beklenen dizedir):

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

Sanırım muhtemelen böyle yazmalısınız (lambda - anonim işlev kullanarak):

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

Bu, aşağıdaki örnekte doğrulanmıştır:

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

Douglas Crockford, "yeni Hata () at ()" (prototipleme yolu) kullanmak yerine bu yaklaşımı önemle önerir:

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

Tek amacı başka birini sarmak olan anonim bir işlev oluşturmaktan daha zarif bir çözüm, es5'in bindişlevini kullanmaktır . Bind işlevi, çağrıldığında, thisanahtar sözcüğü sağlanan değere ayarlanmış olan ve yeni işlev çağrıldığında sağlanan herhangi bir bağımsız değişken sırası ile yeni bir işlev oluşturur.

Onun yerine:

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

Düşünmek:

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

Bağlama sözdizimi, farklı thisdeğerlere sahip işlevleri test etmenizi sağlar ve bence testi daha okunabilir hale getirir. Ayrıca bakınız: https://stackoverflow.com/a/13233194/1248889

Jasmine'in toThrow eşleştiricisini, istisnanın name özelliğiyle veya message özelliğiyle eşleştirmenize izin veren aşağıdakilerle değiştiriyorum. Benim için bu, aşağıdakileri yapabileceğim için testlerin yazılmasını ve daha az kırılgan olmasını sağlar:

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

ve ardından aşağıdakileri test edin:

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

Bu, önemli mesajı beklenen istisna türünü atması durumunda, istisna mesajını daha sonra testleri kırmadan değiştirmeme izin veriyor.

Bu, aşağıdakilere izin veren toThrow'un yerine geçer:

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

Daha önce de belirtildiği gibi, bir fonksiyonun toThrowtestinizde tanımladığınız fonksiyon olduğu için aktarılması gerekir : "Bu fonksiyonun x atmasını bekliyorum"

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

Jasmine Eşleştiricileri kullanıyorsanız , duruma uygun olduklarında aşağıdakilerden birini de kullanabilirsiniz;

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

veya

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

Daha fazla kod olduğunu biliyorum ama sen de yapabilirsin:

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

Kahve severler için

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

Hala bu sorunla karşı karşıya kalan herkes için, benim için gönderilen çözüm işe yaramadı ve bu hatayı atmaya devam etti: Error: Expected function to throw an exception. Daha sonra bir hata atmayı beklediğim fonksiyonun bir asenkron işlev olduğunu ve söz vermeyi beklediğini fark ettim. reddedildi ve sonra hata atmak ve benim kodda yapıyordum:

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

ve bu benim testte yaptığım ve işe yaradı:

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