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