public async Task TestAssetSynchronization()
{
var code = @"class Test { void Method() { } }";
using var workspace = TestWorkspace.CreateCSharp(code);
var solution = workspace.CurrentSolution;
// build checksum
await solution.State.GetChecksumAsync(CancellationToken.None);
var map = await solution.GetAssetMapAsync(CancellationToken.None);
using var remoteWorkspace = CreateRemoteWorkspace();
var sessionId = 0;
var storage = new SolutionAssetCache();
var assetSource = new SimpleAssetSource(workspace.Services.GetService <ISerializerService>(), map);
var service = new AssetProvider(sessionId, storage, assetSource, remoteWorkspace.Services.GetService <ISerializerService>());
await service.SynchronizeAssetsAsync(new HashSet <Checksum>(map.Keys), CancellationToken.None);
foreach (var kv in map)
{
Assert.True(storage.TryGetAsset <object>(kv.Key, out _));
}
}
public async Task TestCleanup()
{
var storage = new SolutionAssetCache(
cleanupInterval: TimeSpan.FromMilliseconds(1),
purgeAfter: TimeSpan.FromMilliseconds(2),
gcAfter: TimeSpan.FromMilliseconds(5)
);
var checksum = Checksum.Create(
WellKnownSynchronizationKind.Null,
ImmutableArray.CreateRange(Guid.NewGuid().ToByteArray())
);
var data = new object();
Assert.True(storage.TryAddAsset(checksum, data));
for (var i = 0; i < 10; i++)
{
await Task.Delay(10);
if (!storage.TryGetAsset(checksum, out object _))
{
// asset is deleted
return;
}
}
// it should not reach here
Assert.True(false, "asset not cleaned up");
}
private async Task TestAssetAsync(object data)
{
var sessionId = 0;
var checksum = Checksum.Create(WellKnownSynchronizationKind.Null, ImmutableArray.CreateRange(Guid.NewGuid().ToByteArray()));
using var workspace = TestWorkspace.CreateCSharp(file: @"");
using var remoteWorkspace = CreateRemoteWorkspace();
var storage = new SolutionAssetCache();
var assetSource = new SimpleAssetSource(workspace.Services.GetService <ISerializerService>(), new Dictionary <Checksum, object>()
{
{ checksum, data }
});
var provider = new AssetProvider(sessionId, storage, assetSource, remoteWorkspace.Services.GetService <ISerializerService>());
var stored = await provider.GetAssetAsync <object>(checksum, CancellationToken.None);
Assert.Equal(data, stored);
var stored2 = await provider.GetAssetsAsync <object>(new[] { checksum }, CancellationToken.None);
Assert.Equal(1, stored2.Count);
Assert.Equal(checksum, stored2[0].Item1);
Assert.Equal(data, stored2[0].Item2);
}
public async Task TestSolutionSynchronization()
{
var code = @"class Test { void Method() { } }";
using var workspace = TestWorkspace.CreateCSharp(code);
var solution = workspace.CurrentSolution;
// build checksum
await solution.State.GetChecksumAsync(CancellationToken.None);
var map = await solution.GetAssetMapAsync(CancellationToken.None);
using var remoteWorkspace = CreateRemoteWorkspace();
var sessionId = 0;
var storage = new SolutionAssetCache();
var assetSource = new SimpleAssetSource(
workspace.Services.GetService <ISerializerService>(),
map
);
var service = new AssetProvider(
sessionId,
storage,
assetSource,
remoteWorkspace.Services.GetService <ISerializerService>()
);
await service.SynchronizeSolutionAssetsAsync(
await solution.State.GetChecksumAsync(CancellationToken.None),
CancellationToken.None
);
TestUtils.VerifyAssetStorage(map, storage);
}
public void TestGetAssets()
{
var storage = new SolutionAssetCache();
var checksum = Checksum.Create(WellKnownSynchronizationKind.Null, ImmutableArray.CreateRange(Guid.NewGuid().ToByteArray()));
var data = new object();
Assert.True(storage.TryAddAsset(checksum, data));
Assert.True(storage.TryGetAsset(checksum, out object _));
}
public WorkspaceManager(SolutionAssetCache assetStorage, Type[]?additionalRemoteParts)
: base(assetStorage)
{
LazyWorkspace = new Lazy <RemoteWorkspace>(
() =>
new RemoteWorkspace(
FeaturesTestCompositions.RemoteHost
.AddParts(additionalRemoteParts)
.GetHostServices(),
WorkspaceKind.RemoteWorkspace
)
);
}
private static async Task <AssetProvider> GetAssetProviderAsync(Workspace workspace, Workspace remoteWorkspace, Solution solution, Dictionary <Checksum, object> map = null)
{
// make sure checksum is calculated
await solution.State.GetChecksumAsync(CancellationToken.None);
map ??= new Dictionary <Checksum, object>();
await solution.AppendAssetMapAsync(map, CancellationToken.None);
var sessionId = Checksum.Create(ImmutableArray.CreateRange(Guid.NewGuid().ToByteArray()));
var storage = new SolutionAssetCache();
var assetSource = new SimpleAssetSource(workspace.Services.GetService <ISerializerService>(), map);
return(new AssetProvider(sessionId, storage, assetSource, remoteWorkspace.Services.GetService <ISerializerService>()));
}
public WorkspaceManager(SolutionAssetCache assetStorage, ConcurrentDictionary <Guid, TestGeneratorReference> sharedTestGeneratorReferences, Type[]?additionalRemoteParts)
: base(assetStorage)
{
LazyWorkspace = new Lazy <RemoteWorkspace>(
() =>
{
var hostServices = FeaturesTestCompositions.RemoteHost.AddParts(additionalRemoteParts).GetHostServices();
// We want to allow references to source generators to be shared between the "in proc" and "remote" workspaces and
// MEF compositions, so tell the serializer service to use the same map for this "remote" workspace as the in-proc one.
((IMefHostExportProvider)hostServices).GetExportedValue <TestSerializerService.Factory>().SharedTestGeneratorReferences = sharedTestGeneratorReferences;
return(new RemoteWorkspace(hostServices, WorkspaceKind.RemoteWorkspace));
});
}
private static async Task <AssetProvider> GetAssetProviderAsync(Workspace workspace, Workspace remoteWorkspace, Solution solution, Dictionary <Checksum, object> map = null)
{
// make sure checksum is calculated
await solution.State.GetChecksumAsync(CancellationToken.None);
map ??= new Dictionary <Checksum, object>();
await solution.AppendAssetMapAsync(includeProjectCones : true, map, CancellationToken.None);
var sessionId = 0;
var storage = new SolutionAssetCache();
var assetSource = new SimpleAssetSource(workspace.Services.GetService <ISerializerService>(), map);
return(new AssetProvider(sessionId, storage, assetSource, remoteWorkspace.Services.GetService <ISerializerService>()));
}
public static void VerifyAssetStorage <T>(
IEnumerable <KeyValuePair <Checksum, T> > items,
SolutionAssetCache storage
)
{
foreach (var kv in items)
{
if (kv.Value is ChecksumCollection)
{
// ChecksumCollection itself won't be in asset storage. since
// it will be never asked from OOP side to host to sync.
// the collection is already part of
// Solution/Project/DocumentStateCheckum so syncing
// state checksum automatically bring in the collection.
// it only exist to calculate hierarchical checksum
continue;
}
Assert.True(storage.TryGetAsset(kv.Key, out object _));
}
}
public async Task TestProjectSynchronization()
{
var code = @"class Test { void Method() { } }";
using var workspace = TestWorkspace.CreateCSharp(code);
var project = workspace.CurrentSolution.Projects.First();
// build checksum
await project.State.GetChecksumAsync(CancellationToken.None);
var map = await project.GetAssetMapAsync(CancellationToken.None);
using var remoteWorkspace = CreateRemoteWorkspace();
var sessionId = 0;
var storage = new SolutionAssetCache();
var assetSource = new SimpleAssetSource(map);
var service = new AssetProvider(sessionId, storage, assetSource, remoteWorkspace.Services.GetService <ISerializerService>());
await service.SynchronizeProjectAssetsAsync(SpecializedCollections.SingletonEnumerable(await project.State.GetChecksumAsync(CancellationToken.None)), CancellationToken.None);
TestUtils.VerifyAssetStorage(map, storage);
}
