public StoreItem(IFileInfo fileInfo, BundleCacheData data)
{
FileInfo = fileInfo;
Timestamp = data.Timestamp;
Version = data.Version;
IsExpired = false;
}
public StoreItemMetadata(string itemFileName, BundleCacheData data, IBundleCacheOptions cacheOptions)
{
ItemFileName = itemFileName;
Timestamp = data.Timestamp;
Version = data.Version;
AbsoluteExpiration = cacheOptions.AbsoluteExpiration;
SlidingExpiration = cacheOptions.SlidingExpiration;
}
public virtual async Task Remove()
{
Setup();
try
{
var data = new BundleCacheData
{
Version = "1",
Timestamp = DateTimeOffset.UtcNow,
Content = Encoding.UTF8.GetBytes("html { }")
};
var key = new BundleCacheKey(0, "/test.css", QueryString.Empty);
var factoryRun = false;
IBundleCacheItem addItem = await Cache.GetOrAddAsync(key, ct =>
{
factoryRun = true;
return(Task.FromResult(data));
}, CancellationToken.None, BundleCacheOptions.Default, lockFile : true);
Assert.True(factoryRun);
if (addItem.FileReleaser != NullDisposable.Instance)
{
// file is not released so the next call must block (remove should acquire a writer lock)
Task removeItemTask = Cache.RemoveAsync(key, CancellationToken.None);
await AsyncHelper.NeverCompletesAsync(removeItemTask);
// releasing file
addItem.FileReleaser.Dispose();
try { await removeItemTask; }
catch (ApplicationException) { }
}
// re-checking
await Cache.RemoveAsync(key, CancellationToken.None);
factoryRun = false;
await Cache.GetOrAddAsync(key, ct =>
{
factoryRun = true;
return(Task.FromResult(data));
}, CancellationToken.None, BundleCacheOptions.Default, lockFile : false);
Assert.True(factoryRun);
}
finally
{
Teardown();
}
}
public virtual async Task Options_AbsoluteExpiration()
{
Setup(expirationScanFrequency: TimeSpan.FromSeconds(0.1));
try
{
var data = new BundleCacheData
{
Version = "1",
Timestamp = DateTimeOffset.UtcNow,
Content = Encoding.UTF8.GetBytes("html { }")
};
var key = new BundleCacheKey(0, "/test.css", QueryString.Empty);
var factoryRun = false;
await Cache.GetOrAddAsync(key, ct =>
{
factoryRun = true;
return(Task.FromResult(data));
}, CancellationToken.None, new BundleCacheOptions { AbsoluteExpiration = Clock.UtcNow.AddSeconds(1) }, lockFile : false);
Assert.True(factoryRun);
factoryRun = false;
await Cache.GetOrAddAsync(key, ct =>
{
factoryRun = true;
return(Task.FromResult(new BundleCacheData()));
}, CancellationToken.None, BundleCacheOptions.Default, lockFile : false);
Assert.False(factoryRun);
await Task.Delay(TimeSpan.FromSeconds(3));
factoryRun = false;
await Cache.GetOrAddAsync(key, ct =>
{
factoryRun = true;
return(Task.FromResult(data));
}, CancellationToken.None, new BundleCacheOptions { AbsoluteExpiration = Clock.UtcNow.AddSeconds(1) }, lockFile : false);
Assert.True(factoryRun);
}
finally
{
Teardown();
}
}
public Item(IFileInfo fileInfo, BundleCacheData metadata)
{
FileInfo = fileInfo;
Version = metadata.Version;
}
public virtual async Task GetOrAdd()
{
Setup();
try
{
var data = new BundleCacheData
{
Version = "1",
Timestamp = DateTimeOffset.UtcNow,
Content = Encoding.UTF8.GetBytes("html { }")
};
var key = new BundleCacheKey(0, "/test.css", QueryString.Empty);
var factoryRun = false;
IBundleCacheItem addItem = await Cache.GetOrAddAsync(key, ct =>
{
factoryRun = true;
return(Task.FromResult(data));
}, CancellationToken.None, BundleCacheOptions.Default, lockFile : true);
Assert.True(factoryRun);
if (addItem.FileReleaser != NullDisposable.Instance)
{
// file is not released so the next call must block (using a parametrized key will force acquiring a writer lock)
var key2 = new BundleCacheKey(key.ManagerId, key.Path, new QueryString("?q"));
Task <IBundleCacheItem> getItemTask = Cache.GetOrAddAsync(key2, ct => throw new ApplicationException(), CancellationToken.None, BundleCacheOptions.Default, lockFile: false);
await AsyncHelper.NeverCompletesAsync(getItemTask);
// releasing file
addItem.FileReleaser.Dispose();
try { await getItemTask; }
catch (ApplicationException) { }
}
// re-checking
factoryRun = false;
IBundleCacheItem getItem = await Cache.GetOrAddAsync(key, ct =>
{
factoryRun = true;
return(Task.FromResult(new BundleCacheData()));
}, CancellationToken.None, BundleCacheOptions.Default, lockFile : false);
Assert.False(factoryRun);
Assert.Equal(data.Version, getItem.Version);
Assert.Equal(data.Timestamp, getItem.Timestamp);
Assert.True(!ProvidesPhysicalFiles ^ getItem.FileInfo is PhysicalFileInfo);
Assert.Equal(data.Content, await FileHelper.GetContentAsync(getItem.FileInfo));
// file lock was not requested so next call must not block
factoryRun = false;
getItem = await Cache.GetOrAddAsync(key, ct =>
{
factoryRun = true;
return(Task.FromResult(new BundleCacheData()));
}, CancellationToken.None, BundleCacheOptions.Default, lockFile : false);
Assert.False(factoryRun);
}
finally
{
Teardown();
}
}
