public async Task TestSessionWithNoSolution()
        {
            using var workspace = CreateWorkspace();

            var service = workspace.Services.GetRequiredService <IRemoteHostClientProvider>();

            var mock   = new MockLogService();
            var client = await service.TryGetRemoteHostClientAsync(CancellationToken.None);

            using var connection = client.CreateConnection <IRemoteSymbolSearchUpdateService>(
                      callbackTarget: mock
                      );
            Assert.True(
                await connection.TryInvokeAsync(
                    (service, callbackId, cancellationToken) =>
                    service.UpdateContinuouslyAsync(
                        callbackId,
                        "emptySource",
                        Path.GetTempPath(),
                        cancellationToken
                        ),
                    CancellationToken.None
                    )
                );
        }
        public async Task LoginCommand_Exception_TestAsync()
        {
            await _viewModel.NavigatedToAsync <object>(null);

            _viewModel.Username = "******";
            _viewModel.Password = "******";
            _mockLoginDataAccess.Setup(x => x.Login(It.IsAny <string>(), It.IsAny <string>()))
            .ThrowsAsync(new Exception());
            _viewModel.LoginCommand.Execute(null);
            MockLogService.Verify(x => x.WriteError(It.IsAny <Exception>()));
        }
Beispiel #3
0
        public async Task TestSessionWithNoSolution()
        {
            var service = CreateRemoteHostClientService();

            service.Enable();

            var mock   = new MockLogService();
            var client = await service.GetRemoteHostClientAsync(CancellationToken.None);

            using (var session = await client.TryCreateServiceSessionAsync(WellKnownServiceHubServices.RemoteSymbolSearchUpdateEngine, mock, CancellationToken.None))
            {
                await session.InvokeAsync(nameof(IRemoteSymbolSearchUpdateEngine.UpdateContinuouslyAsync), "emptySource", Path.GetTempPath());
            }

            service.Disable();
        }
        public async Task TestSessionWithNoSolution()
        {
            using var workspace = CreateWorkspace();

            var service = workspace.Services.GetRequiredService <IRemoteHostClientProvider>();

            var mock   = new MockLogService();
            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);
        }
Beispiel #5
0
        public async Task TestSessionWithNoSolution()
        {
            var service = CreateRemoteHostClientService();

            service.Enable();

            var mock   = new MockLogService();
            var client = await service.TryGetRemoteHostClientAsync(CancellationToken.None);

            var session = await client.TryCreateKeepAliveSessionAsync(WellKnownServiceHubServices.RemoteSymbolSearchUpdateEngine, mock, CancellationToken.None);

            var result = await session.TryInvokeAsync(nameof(IRemoteSymbolSearchUpdateEngine.UpdateContinuouslyAsync), new object[] { "emptySource", Path.GetTempPath() }, CancellationToken.None);

            Assert.True(result);

            session.Shutdown(CancellationToken.None);

            service.Disable();
        }