public void GetTimeout_ThrowsForTooLargeFallback()
{
var exception = Assert.Throws <ArgumentOutOfRangeException>(
() => TimeoutUtilities.GetTimeout("1", TimeSpan.MaxValue));
Assert.Equal("fallbackTimeout", exception.ParamName);
}
/// <summary>
/// Reinitializes static state.
/// </summary>
/// <remarks>This is non-private only to facilitate unit testing.
/// This should not be called by product code.</remarks>
/// <param name="reader">An environment variable reader.</param>
/// <param name="pluginDiscoverer">A lazy plugin discoverer.</param>
/// <param name="pluginFactoryCreator">A plugin factory creator.</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="reader" /> is <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="pluginDiscoverer" />
/// is <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="pluginFactoryCreator" />
/// is <c>null</c>.</exception>
public void Reinitialize(IEnvironmentVariableReader reader,
Lazy <IPluginDiscoverer> pluginDiscoverer,
Func <TimeSpan, IPluginFactory> pluginFactoryCreator)
{
if (reader == null)
{
throw new ArgumentNullException(nameof(reader));
}
if (pluginDiscoverer == null)
{
throw new ArgumentNullException(nameof(pluginDiscoverer));
}
if (pluginFactoryCreator == null)
{
throw new ArgumentNullException(nameof(pluginFactoryCreator));
}
EnvironmentVariableReader = reader;
_rawPluginPaths = reader.GetEnvironmentVariable(_pluginPathsEnvironmentVariable);
_connectionOptions = ConnectionOptions.CreateDefault(reader);
var idleTimeoutInSeconds = EnvironmentVariableReader.GetEnvironmentVariable(_idleTimeoutEnvironmentVariable);
var idleTimeout = TimeoutUtilities.GetTimeout(idleTimeoutInSeconds, PluginConstants.IdleTimeout);
_discoverer = pluginDiscoverer;
_pluginFactory = pluginFactoryCreator(idleTimeout);
_pluginOperationClaims = new ConcurrentDictionary <PluginPackageSourceKey, Lazy <Task <IReadOnlyList <OperationClaim> > > >();
_pluginUtilities = new ConcurrentDictionary <string, Lazy <IPluginMulticlientUtilities> >(
StringComparer.OrdinalIgnoreCase);
}
public void GetTimeout_ReturnsFallbackForInvalidValues(string timeoutInSeconds)
{
var fallbackTimeout = new TimeSpan(days: 0, hours: 1, minutes: 2, seconds: 3, milliseconds: 4);
var actualTimeout = TimeoutUtilities.GetTimeout(timeoutInSeconds, fallbackTimeout);
Assert.Equal(fallbackTimeout, actualTimeout);
}
private static TimeSpan GetRequestTimeout(string requestTimeoutInSeconds)
{
int seconds;
if (int.TryParse(requestTimeoutInSeconds, out seconds))
{
try
{
var requestTimeout = TimeSpan.FromSeconds(seconds);
if (TimeoutUtilities.IsValid(requestTimeout))
{
return requestTimeout;
}
}
catch (Exception)
{
}
}
return PluginConstants.RequestTimeout;
}
public void IsValid_ReturnsTrueForMaximumAcceptableTimeSpan()
{
Assert.True(TimeoutUtilities.IsValid(ProtocolConstants.MaxTimeout));
}
public void IsValid_ReturnsFalseForTooLargeTimeSpan()
{
var milliseconds = int.MaxValue + 1L;
Assert.False(TimeoutUtilities.IsValid(TimeSpan.FromMilliseconds(milliseconds)));
}
public void IsValid_ReturnsFalseForNegativeTimeSpan()
{
Assert.False(TimeoutUtilities.IsValid(TimeSpan.FromSeconds(-1)));
}
public void IsValid_ReturnsFalseForTimeSpanZero()
{
Assert.False(TimeoutUtilities.IsValid(TimeSpan.Zero));
}
public void GetTimeout_ReturnsTimeout()
{
var actualTimeout = TimeoutUtilities.GetTimeout("123", ProtocolConstants.MaxTimeout);
Assert.Equal(TimeSpan.FromSeconds(123), actualTimeout);
}
