public void TestOnTimeoutShouldNotFire() { var times = 5; var generator = new Generator(times); _target.Try(() => generator.Next()) .OnTimeout(t => Assert.Fail()) .Until(t => t); }
/// <summary> /// Retrieve a client by client id /// </summary> /// <param name="clientId">The id of the client to retrieve</param> /// <returns></returns> public async Task <Client> FindClientByIdAsync(string clientId) { var op = TableOperation.Retrieve <ClientEntity>(clientId.GetParitionKey(), clientId); var result = await _retryHelper.Try(() => _table.Value.ExecuteAsync(op)).UntilNoException(); var client = result.Result as ClientEntity; return(client != null?JsonConvert.DeserializeObject <Client>(client.Json, _settings) : null); }
public void TestOnSuccessWithNoParameter() { var times = 5; var generator = new Generator(times); var onSuccessTriggered = false; _target.Try(() => generator.Next()) .OnSuccess(() => onSuccessTriggered = true) .Until(t => t); Assert.That(onSuccessTriggered, Is.True); }
public async Task TestTryUntilWithTimeLimitAsync() { var times = 5; var generator = new Generator(times); bool result = false; Assert.That(await RetryHelperTest.MeasureTime(async() => result = await _target.Try(async() => await generator.NextAsync()).WithTimeLimit(RetryHelperTest.Interval * times + RetryHelperTest.Tolerance).Until(t => t)), Is.EqualTo(RetryHelperTest.Interval * times).Within(RetryHelperTest.Tolerance)); Assert.That(result, Is.True); }
public void TestOnTimeoutShouldNotFire() { var times = 5; var generator = new Generator(times); var onTimeoutTriggered = false; _target.Try(() => generator.Next()) .OnTimeout(t => onTimeoutTriggered = true) .Until(t => t); Expect(onTimeoutTriggered, False); }
public void TestTryUntilWithMaxTryCount() { var times = 5; var generator = new Generator(times); bool result = false; Assert.That(RetryHelperTest.MeasureTime(() => result = _target.Try(() => generator.Next()).WithMaxTryCount(times + 1).Until(t => t)), Is.EqualTo(RetryHelperTest.Interval * times).Within(RetryHelperTest.Tolerance)); Assert.That(result, Is.True); }
public void TestOnSuccessAfterFiveTimes() { var times = 5; var generator = new Generator(times); var onSuccessTriggered = false; _target.Try(() => generator.Next()) .OnSuccess(t => onSuccessTriggered = true) .Until(t => t); Expect(onSuccessTriggered, True); }
public void TestTryUntilWithTimeLimit() { var times = 5; var generator = new Generator(times); bool result = false; Expect(RetryHelperTest.CountTime(() => result = _target.Try(() => generator.Next()).WithTimeLimit(RetryHelperTest.Interval * times + RetryHelperTest.Tolerance).Until(t => t)), EqualTo(RetryHelperTest.Interval * times).Within(RetryHelperTest.Tolerance)); Expect(result, True); }
public void TestTryUntilNoExceptionAfterFiveTimes() { var times = 10; var generator = new Generator(times, true); generator.RandomExceptionType = true; bool result = false; Expect(RetryHelperTest.CountTime(() => result = _target.Try(() => generator.Next()).UntilNoException()), EqualTo(RetryHelperTest.Interval * times).Within(RetryHelperTest.Tolerance)); Expect(generator.TriedTimes, EqualTo(times + 1)); Expect(result, True); }
public void TestOnFailureWithNoParameter() { var times = 5; var generator = new Generator(times); var onFailureTriggered = 0; _target.Try(() => generator.Next()) .OnFailure(() => { onFailureTriggered++; }) .Until(t => t); Assert.That(onFailureTriggered, Is.EqualTo(times)); }
public void TestOnFailureAfterFiveTimes() { var times = 5; var generator = new Generator(times); var onFailureTriggered = 0; _target.Try(() => generator.Next()) .OnFailure(t => { Expect(t, False); onFailureTriggered++; }) .Until(t => t); Expect(onFailureTriggered, EqualTo(times)); }
public void TestTryUntilExpectedTime() { var expectedStopTime = DateTime.Now.AddSeconds(1); _target.Try(() => { }).Until(() => DateTime.Now >= expectedStopTime); Assert.That(DateTime.Now, Is.EqualTo(expectedStopTime).Within(TimeSpan.FromMilliseconds(200))); }
public void TestTryUntilExpectedTime() { var expectedStopTime = DateTime.Now.AddSeconds(3); _target.Try(() => DateTime.Now).Until(() => DateTime.Now >= expectedStopTime); Expect(DateTime.Now, EqualTo(expectedStopTime).Within(TimeSpan.FromMilliseconds(300))); }
public async Task TestTryUntilAsyncCondition() { var times = 5; var generator = new Generator(times); var result = await _target.Try(() => Task.FromResult(true)).Until(async() => await generator.NextAsync()); Assert.That(generator.TriedTimes, Is.EqualTo(times + 1)); Assert.IsTrue(result); }
/// <summary> /// Retrieves all the consent for a subject /// </summary> /// <param name="subject">The subject</param> /// <returns></returns> public async Task <IEnumerable <Consent> > LoadAllAsync(string subject) { var query = new TableQuery <ConsentEntity>().Where( TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, subject)); var list = new List <ConsentEntity>(); TableContinuationToken continuationToken = null; do { var result = await _retryHelper.Try(() => _table.Value.ExecuteQuerySegmentedAsync(query, continuationToken)).UntilNoException(); continuationToken = result.ContinuationToken; list.AddRange(result.Results); } while (continuationToken != null); return(list.Select(c => new Consent { ClientId = c.RowKey, Subject = c.PartitionKey, Scopes = c.Scopes.Split(',') })); }
public async Task TestTryUntilExpectedTimeAsync() { var expectedStopTime = DateTime.Now.AddSeconds(1); await _target .Try(async() => await Task.Delay(0)) .Until(() => DateTime.Now >= expectedStopTime); Assert.That(DateTime.Now, Is.EqualTo(expectedStopTime).Within(TimeSpan.FromMilliseconds(200))); }
/// <summary> /// Saves the token with its given key /// </summary> /// <param name="key">The key for the token</param> /// <param name="value">The refresh token to serialize and store</param> public async Task StoreAsync(string key, Token value) { var entity = new TokenTableEntity { PartitionKey = key.GetParitionKey(), RowKey = key, ClientId = value.ClientId, Json = ToJson(value), SubjectId = value.SubjectId }; var op = TableOperation.InsertOrReplace(entity); await _retryHelper.Try(() => _table.Value.ExecuteAsync(op)).UntilNoException(); }
public async Task TestTryUntilNoExceptionAfterFiveTimesAsync() { var times = 10; var generator = new Generator(times, true); generator.RandomExceptionType = true; bool result = false; Assert.That(await RetryHelperTest.MeasureTime(async() => result = await _target.Try(async() => await generator.NextAsync()).UntilNoException()), Is.EqualTo(RetryHelperTest.Interval * times).Within(RetryHelperTest.AsyncTolerance)); Assert.That(generator.TriedTimes, Is.EqualTo(times + 1)); Assert.That(result, Is.True); }