Jasmine：非同期関数でスローされると予想されるエラー

Question

unit2テストでは、私がunit2テストに書きたいと思う非同期関数があります。想像して、私の関数は、このようなものです：

myFunc(a: int): Promise<void> { 
    if (a == 1) 
     throw new Error('a should not be 1'); 

    let body = { 
     value: a 
    }; 
    return apiService.patch('/url/', JSON.stringify(body)).toPromise(); 
} 

さて、私は、もし条件をチェックすると思っています。私は次のコードを試しました。しかし、このテストはいつも私のコードは実際には何も結果を待たないので、失敗します。

it('should throw error if a = 1',() => { 
    expect(() => { 
     mySerivce.myFunc(1); 
    }).toThrow(new Error('a should not be 1')); 
}) 

私は

Answer 1

try catchを使用できます。

これは私が思いついたことであり、ジャスミンのGithub号トラッカーで提案されたものでした。

https://github.com/jasmine/jasmine/issues/1410

function double(a: number): Promise<number> { 
    if (a === 1) { 
     throw new Error('a should not be 1') 
    } 

    return new Promise(function (resolve, reject) { 
     setTimeout(resolve, 100, a * 2) 
    }) 
} 

describe('test double',() => { 
    it('should double any number but 1', async() => { 
     const result = await double(2); 
     expect(result).toBe(4) 
    }); 

    it('should throw an error', async() => { 
     let error; 
     try { 
      await double(1) 
     } catch (e) { 
      error = e; 
     } 
     const expectedError = new Error('a should not be 1'); 
     expect(error).toEqual(expectedError) 

    }) 
}); 

私も自分が少しヘルパー

書い

async function unpackErrorForAsyncFunction(functionToTest: Function, ...otherArgs: any[]): Promise<Error> { 
    let error; 
    try { 
     const result = await functionToTest(...otherArgs); 
    } catch (e) { 
     error = e; 
    } 
    return error; 
} 

function double(a: number): Promise<number> { 
    if (a === 1) { 
     throw new Error('a should not be 1') 
    } 

    return new Promise(function (resolve, reject) { 
     setTimeout(resolve, 100, a * 2) 
    }) 
} 

function times(a: number, b: number): Promise<number> { 
    if (a === 1 && b === 2) { 
     throw new Error('a should not be 1 and 2') 
    } 

    return new Promise(function (resolve, reject) { 
     setTimeout(resolve, 100, a * b) 
    }) 
} 

describe('test times and double with helper',() => { 
    it('double should throw an error with test helper', async() => { 
     const result = await unpackErrorForAsyncFunction(double, 1); 
     const expectedError = new Error('a should not be 1'); 

     expect(result).toEqual(expectedError) 
    }); 

    it('times should throw an error with test helper', async() => { 
     const result = await unpackErrorForAsyncFunction(times, 1, 2); 
     const expectedError = new Error('a should not be 1 and 2'); 

     expect(result).toEqual(expectedError) 
    }); 
}); 

Answer 2

あなたが主張することができます...私は論理のこれらのタイプのためのユニットテストを書く必要があるのか​​分かりませんこの方法は、スパイを使用して、エラーをスローした場合：

import Spy = jasmine.Spy; 
it('should...',() => { 
(mySerivce.myFunc as Spy).and.Callthrough(); 
mySerivce.myFunc(1); 
expect(mySerivce.myFunc).toThrow(); 
}); 

必要に応じて「競合状態」のトラブルを解決するためにfakeASyncを使用しています。

私はそれが役に立ちそうです。