public async Task UpdaterService()
{
var exportProvider = TestHostServices.CreateMinimalExportProvider();
var workspace = new AdhocWorkspace(TestHostServices.CreateHostServices(exportProvider));
workspace.Options = workspace.Options.WithChangedOption(RemoteHostOptions.SolutionChecksumMonitorBackOffTimeSpanInMS, 1);
var listenerProvider = exportProvider.GetExportedValue <AsynchronousOperationListenerProvider>();
var analyzerReference = new AnalyzerFileReference(typeof(object).Assembly.Location, new NullAssemblyAnalyzerLoader());
var service = CreateRemoteHostClientService(workspace, SpecializedCollections.SingletonEnumerable <AnalyzerReference>(analyzerReference), listenerProvider);
service.Enable();
// make sure client is ready
var client = await service.TryGetRemoteHostClientAsync(CancellationToken.None);
// add solution
workspace.AddSolution(SolutionInfo.Create(SolutionId.CreateNewId(), VersionStamp.Default));
// wait for listener
var workspaceListener = listenerProvider.GetWaiter(FeatureAttribute.Workspace);
await workspaceListener.CreateWaitTask();
var listener = listenerProvider.GetWaiter(FeatureAttribute.RemoteHostClient);
await listener.CreateWaitTask();
// checksum should already exist
Assert.True(workspace.CurrentSolution.State.TryGetStateChecksums(out var checksums));
service.Disable();
}
public async Task UpdaterService()
{
var exportProvider = TestHostServices.CreateMinimalExportProvider();
using var workspace = new AdhocWorkspace(TestHostServices.CreateHostServices(exportProvider));
var options = workspace.CurrentSolution.Options
.WithChangedOption(RemoteHostOptions.SolutionChecksumMonitorBackOffTimeSpanInMS, 1)
.WithChangedOption(RemoteTestHostOptions.RemoteHostTest, true);
workspace.TryApplyChanges(workspace.CurrentSolution.WithOptions(options));
var listenerProvider = exportProvider.GetExportedValue <AsynchronousOperationListenerProvider>();
var checksumUpdater = new SolutionChecksumUpdater(workspace, listenerProvider, CancellationToken.None);
var service = workspace.Services.GetRequiredService <IRemoteHostClientProvider>();
// make sure client is ready
using var client = await service.TryGetRemoteHostClientAsync(CancellationToken.None);
// add solution
workspace.AddSolution(SolutionInfo.Create(SolutionId.CreateNewId(), VersionStamp.Default));
// wait for listener
var workspaceListener = listenerProvider.GetWaiter(FeatureAttribute.Workspace);
await workspaceListener.ExpeditedWaitAsync();
var listener = listenerProvider.GetWaiter(FeatureAttribute.SolutionChecksumUpdater);
await listener.ExpeditedWaitAsync();
// checksum should already exist
Assert.True(workspace.CurrentSolution.State.TryGetStateChecksums(out _));
checksumUpdater.Shutdown();
}
public async Task TestSessionClosed()
{
using var workspace = new AdhocWorkspace(TestHostServices.CreateHostServices());
var client = (InProcRemoteHostClient)await InProcRemoteHostClient.CreateAsync(workspace.Services, runCacheCleanup : false).ConfigureAwait(false);
var serviceName = new RemoteServiceName("Test");
// register local service
TestService testService = null;
client.RegisterService(serviceName, (s, p) =>
{
testService = new TestService(s, p);
return(testService);
});
// create session that stay alive until client alive (ex, SymbolSearchUpdateEngine)
using var connection = await client.CreateConnectionAsync(serviceName, callbackTarget : null, CancellationToken.None);
// mimic unfortunate call that happens to be in the middle of communication.
var task = connection.RunRemoteAsync("TestMethodAsync", solution: null, arguments: null, CancellationToken.None);
// make client to go away
client.Dispose();
// let the service to return
testService.Event.Set();
// make sure task finished gracefully
await task;
}
public async Task TestUnknownProject()
{
var workspace = new AdhocWorkspace(TestHostServices.CreateHostServices());
var solution = workspace.CurrentSolution.AddProject("unknown", "unknown", NoCompilationConstants.LanguageName).Solution;
var client = (InProcRemoteHostClient)(await InProcRemoteHostClient.CreateAsync(workspace, runCacheCleanup: false));
await UpdatePrimaryWorkspace(client, solution);
await VerifyAssetStorageAsync(client, solution);
// Only C# and VB projects are supported in Remote workspace.
// See "RemoteSupportedLanguages.IsSupported"
Assert.Empty(RemoteWorkspace.CurrentSolution.Projects);
solution = WithChangedOptionsFromRemoteWorkspace(solution);
Assert.NotEqual(
await solution.State.GetChecksumAsync(CancellationToken.None),
await RemoteWorkspace.CurrentSolution.State.GetChecksumAsync(CancellationToken.None));
solution = solution.RemoveProject(solution.ProjectIds.Single());
solution = WithChangedOptionsFromRemoteWorkspace(solution);
Assert.Equal(
await solution.State.GetChecksumAsync(CancellationToken.None),
await RemoteWorkspace.CurrentSolution.State.GetChecksumAsync(CancellationToken.None));
}
public async Task UpdaterService()
{
var workspace = new AdhocWorkspace(TestHostServices.CreateHostServices());
workspace.Options = workspace.Options.WithChangedOption(RemoteHostOptions.SolutionChecksumMonitorBackOffTimeSpanInMS, 1);
var analyzerReference = new AnalyzerFileReference(typeof(object).Assembly.Location, new NullAssemblyAnalyzerLoader());
var service = CreateRemoteHostClientService(workspace, SpecializedCollections.SingletonEnumerable <AnalyzerReference>(analyzerReference));
service.Enable();
// make sure client is ready
var client = await service.GetRemoteHostClientAsync(CancellationToken.None);
// add solution
workspace.AddSolution(SolutionInfo.Create(SolutionId.CreateNewId(), VersionStamp.Default));
// TODO: use waiter to make sure workspace events and updater is ready.
// this delay is temporary until I set all .Next unit test hardness to setup correctly
await Task.Delay(TimeSpan.FromSeconds(1));
// checksum should already exist
SolutionStateChecksums checksums;
Assert.True(workspace.CurrentSolution.State.TryGetStateChecksums(out checksums));
service.Disable();
}
public async Task TestUnknownProject()
{
var workspace = new AdhocWorkspace(TestHostServices.CreateHostServices());
var solution = workspace.CurrentSolution.AddProject("unknown", "unknown", NoCompilationConstants.LanguageName).Solution;
var client = (InProcRemoteHostClient)(await InProcRemoteHostClient.CreateAsync(workspace, runCacheCleanup: false));
await UpdatePrimaryWorkspace(client, solution);
await VerifyAssetStorageAsync(client, solution);
Assert.Equal(
await solution.State.GetChecksumAsync(CancellationToken.None),
await RemoteWorkspace.CurrentSolution.State.GetChecksumAsync(CancellationToken.None));
}
private RemoteHostClientServiceFactory.RemoteHostClientService CreateRemoteHostClientService(
Workspace workspace = null,
IAsynchronousOperationListenerProvider listenerProvider = null)
{
workspace ??= new AdhocWorkspace(TestHostServices.CreateHostServices());
workspace.TryApplyChanges(workspace.CurrentSolution.WithOptions(workspace.Options
.WithChangedOption(RemoteHostOptions.RemoteHostTest, true)
.WithChangedOption(SolutionCrawlerOptions.BackgroundAnalysisScopeOption, LanguageNames.CSharp, BackgroundAnalysisScope.FullSolution)
.WithChangedOption(SolutionCrawlerOptions.BackgroundAnalysisScopeOption, LanguageNames.VisualBasic, BackgroundAnalysisScope.FullSolution)));
var threadingContext = ((IMefHostExportProvider)workspace.Services.HostServices).GetExports <IThreadingContext>().Single().Value;
var factory = new RemoteHostClientServiceFactory(threadingContext, listenerProvider ?? AsynchronousOperationListenerProvider.NullProvider);
return(factory.CreateService(workspace.Services) as RemoteHostClientServiceFactory.RemoteHostClientService);
}
public async Task SynchronizeGlobalAssets()
{
var workspace = new AdhocWorkspace(TestHostServices.CreateHostServices());
var analyzerReference = new AnalyzerFileReference(typeof(object).Assembly.Location, new NullAssemblyAnalyzerLoader());
var service = CreateRemoteHostClientService(workspace, SpecializedCollections.SingletonEnumerable <AnalyzerReference>(analyzerReference));
service.Enable();
// make sure client is ready
var client = await service.TryGetRemoteHostClientAsync(CancellationToken.None) as InProcRemoteHostClient;
Assert.Equal(1, client.AssetStorage.GetGlobalAssetsOfType <AnalyzerReference>(CancellationToken.None).Count());
service.Disable();
}
private RemoteHostClientServiceFactory.RemoteHostClientService CreateRemoteHostClientService(
Workspace workspace = null,
IEnumerable <AnalyzerReference> hostAnalyzerReferences = null,
IAsynchronousOperationListenerProvider listenerProvider = null)
{
workspace = workspace ?? new AdhocWorkspace(TestHostServices.CreateHostServices());
workspace.Options = workspace.Options.WithChangedOption(RemoteHostOptions.RemoteHostTest, true)
.WithChangedOption(ServiceFeatureOnOffOptions.ClosedFileDiagnostic, LanguageNames.CSharp, true)
.WithChangedOption(ServiceFeatureOnOffOptions.ClosedFileDiagnostic, LanguageNames.VisualBasic, true);
var analyzerService = GetDiagnosticAnalyzerService(hostAnalyzerReferences ?? SpecializedCollections.EmptyEnumerable <AnalyzerReference>());
var factory = new RemoteHostClientServiceFactory(listenerProvider ?? AsynchronousOperationListenerProvider.NullProvider, analyzerService);
return(factory.CreateService(workspace.Services) as RemoteHostClientServiceFactory.RemoteHostClientService);
}
private RemoteHostClientServiceFactory.RemoteHostClientService CreateRemoteHostClientService(
Workspace workspace = null,
IEnumerable <AnalyzerReference> hostAnalyzerReferences = null,
IAsynchronousOperationListenerProvider listenerProvider = null)
{
workspace = workspace ?? new AdhocWorkspace(TestHostServices.CreateHostServices());
workspace.Options = workspace.Options.WithChangedOption(RemoteHostOptions.RemoteHostTest, true)
.WithChangedOption(SolutionCrawlerOptions.BackgroundAnalysisScopeOption, LanguageNames.CSharp, BackgroundAnalysisScope.FullSolution)
.WithChangedOption(SolutionCrawlerOptions.BackgroundAnalysisScopeOption, LanguageNames.VisualBasic, BackgroundAnalysisScope.FullSolution);
var analyzerService = GetDiagnosticAnalyzerService(hostAnalyzerReferences ?? SpecializedCollections.EmptyEnumerable <AnalyzerReference>());
var threadingContext = ((IMefHostExportProvider)workspace.Services.HostServices).GetExports <IThreadingContext>().Single().Value;
var factory = new RemoteHostClientServiceFactory(threadingContext, listenerProvider ?? AsynchronousOperationListenerProvider.NullProvider, analyzerService);
return(factory.CreateService(workspace.Services) as RemoteHostClientServiceFactory.RemoteHostClientService);
}
private RemoteHostClientServiceFactory.RemoteHostClientService CreateRemoteHostClientService(Workspace workspace = null, IEnumerable <AnalyzerReference> hostAnalyzerReferences = null)
{
workspace = workspace ?? new AdhocWorkspace(TestHostServices.CreateHostServices());
workspace.Options = workspace.Options.WithChangedOption(RemoteHostOptions.RemoteHostTest, true)
.WithChangedOption(ServiceFeatureOnOffOptions.ClosedFileDiagnostic, LanguageNames.CSharp, true)
.WithChangedOption(ServiceFeatureOnOffOptions.ClosedFileDiagnostic, LanguageNames.VisualBasic, true);
var analyzerService = GetDiagnosticAnalyzerService(hostAnalyzerReferences ?? SpecializedCollections.EmptyEnumerable <AnalyzerReference>());
var optionMock = new Mock <IEditorOptions>(MockBehavior.Strict);
var optionFactoryMock = new Mock <IEditorOptionsFactoryService>(MockBehavior.Strict);
optionFactoryMock.SetupGet(i => i.GlobalOptions).Returns(optionMock.Object);
var factory = new RemoteHostClientServiceFactory(analyzerService, optionFactoryMock.Object);
return(factory.CreateService(workspace.Services) as RemoteHostClientServiceFactory.RemoteHostClientService);
}
public async Task UpdaterService()
{
var exportProvider = ExportProviderCache
.GetOrCreateExportProviderFactory(ServiceTestExportProvider.CreateAssemblyCatalog()
.WithParts(typeof(InProcRemoteHostClientProvider.Factory), typeof(CSharpOptionsSerializationService)))
.CreateExportProvider();
using var workspace = new AdhocWorkspace(TestHostServices.CreateHostServices(exportProvider));
var options = workspace.CurrentSolution.Options
.WithChangedOption(RemoteHostOptions.SolutionChecksumMonitorBackOffTimeSpanInMS, 1)
.WithChangedOption(RemoteTestHostOptions.RemoteHostTest, true);
workspace.TryApplyChanges(workspace.CurrentSolution.WithOptions(options));
var listenerProvider = exportProvider.GetExportedValue <AsynchronousOperationListenerProvider>();
var checksumUpdater = new SolutionChecksumUpdater(workspace, listenerProvider, CancellationToken.None);
var service = workspace.Services.GetRequiredService <IRemoteHostClientProvider>();
// make sure client is ready
using var client = await service.TryGetRemoteHostClientAsync(CancellationToken.None);
// add solution, change document
workspace.AddSolution(SolutionInfo.Create(SolutionId.CreateNewId(), VersionStamp.Default));
var project = workspace.AddProject("proj", LanguageNames.CSharp);
var document = workspace.AddDocument(project.Id, "doc.cs", SourceText.From("code"));
workspace.ApplyTextChanges(document.Id, new[] { new TextChange(new TextSpan(0, 1), "abc") }, CancellationToken.None);
// wait for listener
var workspaceListener = listenerProvider.GetWaiter(FeatureAttribute.Workspace);
await workspaceListener.ExpeditedWaitAsync();
var listener = listenerProvider.GetWaiter(FeatureAttribute.SolutionChecksumUpdater);
await listener.ExpeditedWaitAsync();
// checksum should already exist
Assert.True(workspace.CurrentSolution.State.TryGetStateChecksums(out _));
checksumUpdater.Shutdown();
}
public async Task TestSessionWithNoSolution()
{
using var workspace = new AdhocWorkspace(TestHostServices.CreateHostServices());
var options = workspace.CurrentSolution.Options
.WithChangedOption(Microsoft.CodeAnalysis.Test.Utilities.RemoteHost.RemoteHostOptions.RemoteHostTest, true);
workspace.TryApplyChanges(workspace.CurrentSolution.WithOptions(options));
var service = workspace.Services.GetRequiredService<IRemoteHostClientProvider>();
var mock = new MockLogAndProgressService();
var client = await service.TryGetRemoteHostClientAsync(CancellationToken.None);
using var connection = await client.CreateConnectionAsync(WellKnownServiceHubService.RemoteSymbolSearchUpdateEngine, callbackTarget: mock, CancellationToken.None);
await connection.RunRemoteAsync(
nameof(IRemoteSymbolSearchUpdateEngine.UpdateContinuouslyAsync),
solution: null,
new object[] { "emptySource", Path.GetTempPath() },
CancellationToken.None);
}
public async Task UpdaterService()
{
var workspace = new AdhocWorkspace(TestHostServices.CreateHostServices());
workspace.Options = workspace.Options.WithChangedOption(RemoteHostOptions.SolutionChecksumMonitorBackOffTimeSpanInMS, 1);
var analyzerReference = new AnalyzerFileReference(typeof(object).Assembly.Location, new NullAssemblyAnalyzerLoader());
var service = CreateRemoteHostClientService(workspace, SpecializedCollections.SingletonEnumerable <AnalyzerReference>(analyzerReference));
service.Enable();
// make sure client is ready
var client = await service.GetRemoteHostClientAsync(CancellationToken.None);
// add solution
workspace.AddSolution(SolutionInfo.Create(SolutionId.CreateNewId(), VersionStamp.Default));
// TODO: use waiter to make sure workspace events and updater is ready.
// this delay is temporary until I set all .Next unit test hardness to setup correctly
await Task.Delay(TimeSpan.FromSeconds(1));
var checksumService = workspace.Services.GetService <ISolutionChecksumService>();
Checksum checksum;
using (var scope = await checksumService.CreateChecksumAsync(workspace.CurrentSolution, CancellationToken.None))
{
// create solution checksum and hold onto the checksum and let it go
checksum = scope.SolutionChecksum.Checksum;
}
// there should be one held in memory by solution checksum updator
var solutionObject = checksumService.GetChecksumObject(checksum, CancellationToken.None);
Assert.Equal(solutionObject.Checksum, checksum);
service.Disable();
}
public async Task GlobalAssets()
{
var workspace = new AdhocWorkspace(TestHostServices.CreateHostServices());
var analyzerReference = new AnalyzerFileReference(typeof(object).Assembly.Location, new NullAssemblyAnalyzerLoader());
var service = CreateRemoteHostClientService(workspace, SpecializedCollections.SingletonEnumerable <AnalyzerReference>(analyzerReference));
service.Enable();
// make sure client is ready
var client = await service.TryGetRemoteHostClientAsync(CancellationToken.None);
var checksumService = workspace.Services.GetService <IRemotableDataService>();
var asset = checksumService.GetGlobalAsset(analyzerReference, CancellationToken.None);
Assert.NotNull(asset);
service.Disable();
var noAsset = checksumService.GetGlobalAsset(analyzerReference, CancellationToken.None);
Assert.Null(noAsset);
}