Jednostka Metoda badania asynchroniczny: Jak wyraźnie stwierdzić, że zadanie zostało anulowane wewnętrzny

Question

Byłem niedawno pisanie asynchronicznej metodę, która wywołuje zewnętrzny długi bieg asynchroniczny metoda więc postanowiłem przejść CancellationToken umożliwiającą anulowanie. Metodę można nazwać jednocześnie.

Wykonanie łączy odczekiwanie wykładniczym i limitu czasu technik opisanych w Stephen Cleary jest książka współbieżności C# Cookbook w następujący sposób;

/// <summary> 
/// Sets bar 
/// </summary> 
/// <param name="cancellationToken">The cancellation token that cancels the operation</param> 
/// <returns>A <see cref="Task"/> representing the task of setting bar value</returns> 
/// <exception cref="OperationCanceledException">Is thrown when the task is cancelled via <paramref name="cancellationToken"/></exception> 
/// <exception cref="TimeoutException">Is thrown when unable to get bar value due to time out</exception> 
public async Task FooAsync(CancellationToken cancellationToken) 
{ 
    TimeSpan delay = TimeSpan.FromMilliseconds(250); 
    for (int i = 0; i < RetryLimit; i++) 
    { 
     if (i != 0) 
     { 
      await Task.Delay(delay, cancellationToken); 
      delay += delay; // Exponential backoff 
     } 

     await semaphoreSlim.WaitAsync(cancellationToken); // Critical section is introduced for long running operation to prevent race condition 

     using (CancellationTokenSource cancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken)) 
     { 
      cancellationTokenSource.CancelAfter(TimeSpan.FromMilliseconds(Timeout)); 
      CancellationToken linkedCancellationToken = cancellationTokenSource.Token; 

      try 
      { 
       cancellationToken.ThrowIfCancellationRequested(); 
       bar = await barService.GetBarAsync(barId, linkedCancellationToken).ConfigureAwait(false); 

       break; 
      } 
      catch (OperationCanceledException) when (!cancellationToken.IsCancellationRequested) 
      { 
       if (i == RetryLimit - 1) 
       { 
        throw new TimeoutException("Unable to get bar, operation timed out!"); 
       } 

       // Otherwise, exception is ignored. Will give it another try 
      } 
      finally 
      { 
       semaphoreSlim.Release(); 
      } 
     } 
    } 
} 

Zastanawiam się, czy powinienem napisać badanej jednostki, która wyraźnie stwierdza, że ​​zadanie zostanie anulowane wewnętrzny barService.GetBarAsync() ilekroć FooAsync() zostanie anulowane. Jeśli tak, jak go wdrożyć w czysty sposób?

Czy powinienem zignorować szczegóły implementacji i po prostu przetestować, który klient/dzwoniący jest zainteresowany, jak opisano w podsumowaniu metody (pasek jest aktualizowany, anulować wyzwalacze OperationCanceledException, limit czasu wyzwala TimeoutException).

Jeśli nie, powinienem dostać moje nogi mokre i rozpoczęcie wdrażania testy jednostkowe w następujących przypadkach:

1. Testowanie jest thread-safe (monitor nabyte tylko przez jeden wątek na raz)
2. Testowanie ponowić mechanizm
3. Testowanie serwer nie jest zalany
4. Testowanie może nawet regularne wyjątek jest propagowana do dzwoniącego

Answer 1

Zastanawiam się, czy powinienem napisać test jednostkowy, który wyraźnie potwierdza, że ​​wewnętrzne zadanie barService.GetBarAsync() jest anulowane, gdy funkcja FooAsync() jest anulowana.

Byłoby łatwiej napisać test, który twierdzi, że anulowanie żeton przekazane GetBarAsync jest anulowany, gdy token anulowanie przekazane FooAsync zostanie anulowane.

Do testowania urządzeń asynchronicznych moim wyborem jest TaskCompletionSource<object> dla sygnałów asynchronicznych i ManualResetEvent dla sygnałów synchronicznych. Od GetBarAsync jest asynchroniczne, użyłbym jednego asynchronicznego np

var cts = new CancellationTokenSource(); // passed into FooAsync 
var getBarAsyncReady = new TaskCompletionSource<object>(); 
var getBarAsyncContinue = new TaskCompletionSource<object>(); 
bool triggered = false; 
[inject] GetBarAsync = async (barId, cancellationToken) => 
{ 
    getBarAsyncReady.SetResult(null); 
    await getBarAsyncContinue.Task; 
    triggered = cancellationToken.IsCancellationRequested; 
    cancellationToken.ThrowIfCancellationRequested(); 
}; 

var task = FooAsync(cts.Token); 
await getBarAsyncReady.Task; 
cts.Cancel(); 
getBarAsyncContinue.SetResult(null); 

Assert(triggered); 
Assert(task throws OperationCanceledException); 

Można użyć sygnałów tak, aby stworzyć coś w rodzaju „lock-step”.

---

Nota boczna: w moim własnym kodzie nigdy nie zapisuję logiki ponownej próby. Używam Polly, który jest w pełni kompatybilny z async i dokładnie przetestowany. Które powodowałyby zmniejszenie semantyki, które muszą być badane w dół do:

1. CT przechodzi przez (pośrednio) do metody usługi, w wyniku OperationCanceledException gdy uruchomiony.
2. Istnieje również limit czasu, w wyniku czego TimeoutException.
3. Wykonanie jest muteksowane.

(1) zostanie wykonane tak jak powyżej. (2) i (3) są mniej łatwe do przetestowania (do prawidłowych testów, wymagających albo MS Fakes lub abstrakcji na czas/muteks). Z pewnością chodzi o zmniejszenie zysków, jeśli chodzi o testowanie jednostek, a od Ciebie zależy, jak daleko chcesz się posunąć.