public void QueryStatus_NonCriticalErrorSuppressed() { // Arrange docLocatorMock.Setup(x => x.FindActiveDocument()).Throws(new InvalidOperationException("exception xxx")); // Act - should not throw var _ = testSubject.OleStatus; logger.AssertPartialOutputStringExists("exception xxx"); }
public async Task GetConfigForFile_FailedToProcessTsConfig_ParsingError_TsConfigIsSkipped() { const string testedFileName = "tested\\file"; var tsConfigsInSolution = new[] { "config1", "config2" }; var tsConfigsLocator = SetupTsConfigsLocator(testedFileName, tsConfigsInSolution); var eslintBridgeClient = new Mock <ITypeScriptEslintBridgeClient>(); var parsingError = new ParsingError { Code = ParsingErrorCode.UNSUPPORTED_TYPESCRIPT, Message = "some message", Line = 5555 }; SetupEslintBridgeResponse(eslintBridgeClient, new Dictionary <string, TSConfigResponse> { { "config1", new TSConfigResponse { ParsingError = parsingError, Files = new[] { testedFileName } // should be ignored } }, { "config2", new TSConfigResponse() } }); var logger = new TestLogger(); var testSubject = CreateTestSubject(tsConfigsLocator.Object, eslintBridgeClient.Object, logger: logger); var result = await testSubject.GetConfigForFile(testedFileName, CancellationToken.None); result.Should().BeNull(); eslintBridgeClient.Verify(x => x.TsConfigFiles("config1", CancellationToken.None), Times.Once); eslintBridgeClient.Verify(x => x.TsConfigFiles("config2", CancellationToken.None), Times.Once); eslintBridgeClient.VerifyNoOtherCalls(); logger.AssertPartialOutputStringExists(parsingError.Message, parsingError.Code.ToString(), parsingError.Line.ToString()); }
[DataRow("PROJECT=p&SERVER=http://s", "hotspot")] // lookup is not case sensitive -> only hotspot is missing public async Task ProcessRequest_MissingParameter_Returns400StatusCode(string wholeQueryString, string missingParamList) { var testLogger = new TestLogger(logToConsole: true); var apiHandlerMock = new Mock <IOpenInIDERequestHandler>(); var context = CreateContext(wholeQueryString); var testSubject = new ShowHotspotOwinRequestHandler(apiHandlerMock.Object, testLogger); // Act await testSubject.ProcessRequest(context); context.Response.StatusCode.Should().Be(400); // Note: passing a variable number of items to a test is messy. Here, it's // simpler to pass a string and split it. var missingParamNames = missingParamList.Split(';'); foreach (var paramName in missingParamNames) { testLogger.AssertPartialOutputStringExists(paramName); } CheckApiHandlerNotCalled(apiHandlerMock); }
public async Task GetRules_AbortIfCancellationRequested() { // Arrange var testLogger = new TestLogger(); CancellationTokenSource cts = new CancellationTokenSource(); var serviceMock = new Mock <ISonarQubeService>(); serviceMock.Setup(x => x.GetRulesAsync(It.IsAny <bool>(), It.IsAny <string>(), It.IsAny <CancellationToken>())) .ReturnsAsync(() => { cts.Cancel(); return(new List <SonarQubeRule>()); }); var testSubject = new CFamilyBindingConfigProvider(serviceMock.Object, testLogger); // Act var result = await testSubject.GetConfigurationAsync(CreateQp(), null, Language.Cpp, cts.Token); // Assert result.Should().BeNull(); testLogger.AssertPartialOutputStringExists(CoreStrings.SonarQubeRequestTimeoutOrCancelled); }
public void DisableExcludedRules_CustomRulesAndExcludedRulesExist_CustomRulesAreUnchangedExcludedRulesAreDisabled() { // Arrange var testLogger = new TestLogger(); var excluded = new string[] { "excluded1", "excluded2", "excluded3", "excluded4" }; var custom = new RulesSettings() .AddRule("xxx", RuleLevel.On) .AddRule("excluded1", RuleLevel.On) .AddRule("yyy", RuleLevel.Off) .AddRule("excluded2", RuleLevel.Off) .AddRule("excluded4", RuleLevel.On); // Act var result = DynamicCFamilyRulesConfig.DisableExcludedRules(custom, excluded, testLogger); // Assert result.Should().NotBeSameAs(custom); custom.Rules.Count.Should().BeLessThan(result.Rules.Count); result.Rules.Keys.Should().BeEquivalentTo("xxx", "excluded1", "yyy", "excluded2", "excluded3", "excluded4"); result.Rules["xxx"].Level.Should().Be(RuleLevel.On); result.Rules["excluded1"].Level.Should().Be(RuleLevel.Off); // changed from On to Off result.Rules["yyy"].Level.Should().Be(RuleLevel.Off); result.Rules["excluded2"].Level.Should().Be(RuleLevel.Off); // unchanged - still Off result.Rules["excluded4"].Level.Should().Be(RuleLevel.Off); // changed from On to Off testLogger.AssertPartialOutputStringExists("excluded1", "excluded2", "excluded3", "excluded4"); }
public void GetBindAction_LoggerWritten() { var bindAction = testSubject.GetBindAction(null, new ProjectMock("c:\\test.csproj"), CancellationToken.None); bindAction.Should().NotBeNull(); logger.AssertPartialOutputStringExists("test.csproj"); }
public async Task Analyze_EslintBridgeClientNotInitializedResponse_FollowedByParsingError_ParsingErrorIsLogged() { var logger = new TestLogger(); var linterNotInitializedResponse = CreateLinterNotInitializedResponse(); var parsingErrorResponse = new AnalysisResponse { ParsingError = new ParsingError { Code = ParsingErrorCode.MISSING_TYPESCRIPT, Line = 5, Message = "some message" } }; var client = new Mock <IEslintBridgeClient>(); client .SetupSequence(x => x.Analyze("some path", "some config", CancellationToken.None)) .ReturnsAsync(linterNotInitializedResponse) .ReturnsAsync(parsingErrorResponse); var testSubject = CreateTestSubject(client.Object, logger: logger); await testSubject.Analyze("some path", "some config", CancellationToken.None); logger.AssertPartialOutputStringExists(Resources.ERR_ParsingError_MissingTypescript); }
public void AnalysisFailed_AggregateException_LogToOutputWindow() { var exception = new AggregateException( new List <Exception> { new ArgumentNullException("this is a test1"), new NotImplementedException("this is a test2") }); var filePath = "c:\\test\\foo-started.cpp"; testSubject.AnalysisFailed(filePath, exception); logger.AssertPartialOutputStringExists("this is a test1"); logger.AssertPartialOutputStringExists("this is a test2"); logger.OutputStrings.Count.Should().Be(1); }
public async Task Analyze_ResponseWithParsingError_ParsingErrorLogged(int errorCode) { var logger = new TestLogger(); var parsingError = new ParsingError { Code = (ParsingErrorCode)errorCode, Line = 5, Message = "some message" }; await SetupAnalysisWithParsingError(parsingError, logger); logger.AssertPartialOutputStringExists(parsingError.Code.ToString()); logger.AssertPartialOutputStringExists(parsingError.Message); logger.AssertPartialOutputStringExists(parsingError.Line.ToString()); }
public void LifeCycle_ProgressChanged_NonCriticalException_Suppressed() { // Arrange bool opExecuted = false; dummyStatusBar.ProgressOperation = () => { opExecuted = true; throw new InvalidOperationException("xxx"); }; var progressHandler = new StatusBarDownloadProgressHandler(dummyStatusBar, dummyInstaller, logger); // Act and Assert: exception should be suppressed dummyInstaller.SimulateProgressChanged(new InstallationProgressChangedEventArgs(0, 1000)); opExecuted.Should().BeTrue(); logger.AssertPartialOutputStringExists("xxx"); }
private void VerifyExceptionCaughtAndLogged(Exception setupException, IAnalysisIssueLocationVisualization location) { var result = true; Action act = () => result = testSubject.TryNavigate(location); act.Should().NotThrow(); result.Should().BeFalse(); logger.AssertPartialOutputStringExists(setupException.Message); }
public void Ctor_FailsToRetrieveFileIcon_BlankIcon() { var location = CreateMockLocation("c:\\test\\c1.c", KnownMonikers.CFile, new NotImplementedException("this is a test")); var testSubject = CreateTestSubject(location.Object); testSubject.Icon.Should().BeEquivalentTo(KnownMonikers.Blank, c => c.ComparingByMembers <ImageMoniker>()); logger.AssertPartialOutputStringExists("this is a test"); logger.OutputStrings.Count.Should().Be(1); }
public void HttpRequestException_NoInnerException_IsHandledAndLogged() { // Arrange var testLogger = new TestLogger(); // Act WebServiceHelper.SafeServiceCallAsync <bool>(() => throw new HttpRequestException("outer message"), testLogger).Wait(); // Assert testLogger.AssertPartialOutputStringExists("outer message"); }
public void BringToFront_NonCriticalExceptions_IsSuppressed() { var testSubject = new IDEWindowService(nativeMock.Object, processMock.Object, logger); nativeMock.Setup(x => x.SetForegroundWindow(ValidHandle)) .Throws(new InvalidOperationException("thrown from test code")); // Act testSubject.BringToFront(); logger.AssertPartialOutputStringExists("thrown from test code"); }
public void NonCriticalException_IsSuppressed() { // Arrange var testLogger = new TestLogger(); // Act WebServiceHelper.SafeServiceCallAsync <bool>(() => throw new ArgumentNullException("dummy error message"), testLogger).Wait(); // Assert testLogger.AssertPartialOutputStringExists("dummy error message"); }
public void NonCriticalErrorInListener_IsSuppressedAndLogged() { var logger = new TestLogger(); var testSubject = new AnalysisRequester(logger); testSubject.AnalysisRequested += (s, e) => throw new ArgumentException("XXX yyy"); // Act testSubject.RequestAnalysis(); // Assert logger.AssertPartialOutputStringExists("XXX yyy"); }
public async Task ProcessRequest_UnrecognisedPath_Returns404(string requestedPath) { var testLogger = new TestLogger(logToConsole: true); var context = CreateOwinContext(requestedPath); var handler = CreateHandler("/sonarlint/api/handled"); var testSubject = new OwinPipelineProcessor(new[] { handler }, testLogger); await testSubject.ProcessRequest(context.Environment).ConfigureAwait(false); context.Response.StatusCode.Should().Be(404); CheckCorsHeader(context); testLogger.AssertPartialOutputStringExists(requestedPath); }
private void VerifyValidationFailed(TestConfigurationSetup solutionTestConfigurationSetup, string failureReasonString) { var configProvider = solutionTestConfigurationSetup == null ? SetupConfigurationProvider(BindingConfiguration.Standalone) : SetupConfigurationProvider(CreateBindingConfiguration(solutionTestConfigurationSetup)); var logger = new TestLogger(); var testSubject = new OpenInIdeStateValidator(configProvider, logger); var result = testSubject.CanHandleOpenInIDERequest(new Uri(RequestConfiguration.ServerUrl), RequestConfiguration.ProjectKey, RequestConfiguration.OrganizationKey); result.Should().BeFalse(); logger.AssertPartialOutputStringExists(failureReasonString); }
public async Task SynchronizeWithServer_SonarQubeServerNotYetConnected_StoreCleared() { var converter = new Mock <ITaintIssueToIssueVisualizationConverter>(); var taintStore = new Mock <ITaintStore>(); var sonarService = CreateSonarService(isConnected: false); var logger = new TestLogger(); var testSubject = CreateTestSubject(taintStore.Object, converter.Object, sonarService: sonarService.Object, logger: logger); await testSubject.SynchronizeWithServer(); logger.AssertPartialOutputStringExists("not yet established"); CheckIssuesAreNotFetched(sonarService); CheckStoreIsCleared(taintStore); }
public async Task Analyze_ResponseWithParsingError_UnsupportedTypescript_ParsingErrorLogged() { var logger = new TestLogger(); var parsingError = new ParsingError { Code = ParsingErrorCode.UNSUPPORTED_TYPESCRIPT, Line = 5, Message = "some message" }; await SetupAnalysisWithParsingError(parsingError, logger); logger.AssertPartialOutputStringExists(TypeScript.Analyzer.Resources.ERR_ParsingError_UnsupportedTypescript); }
public void Execute_NonCriticalException_IsSuppressed() { var logger = new TestLogger(logToConsole: true); var toolwindowServiceMock = new Mock <IToolWindowService>(); toolwindowServiceMock.Setup(x => x.Show(ValidToolWindowId)).Throws(new InvalidOperationException("thrown by test")); var testSubject = new ShowToolWindowCommand(ValidCommandId, ValidToolWindowId, toolwindowServiceMock.Object, Mock.Of <IMenuCommandService>(), logger); // Act testSubject.Execute(null, null); toolwindowServiceMock.Verify(x => x.Show(ValidToolWindowId), Times.Once); logger.AssertPartialOutputStringExists(ValidToolWindowId.ToString(), "thrown by test"); }
public async Task ExecuteAnalysis_ResponseWithParsingError_MissingTypescript_ParsingErrorLogged() { var logger = new TestLogger(); var parsingError = new ParsingError { Code = ParsingErrorCode.MISSING_TYPESCRIPT, Line = 5, Message = "some message" }; await SetupAnalysisWithParsingError(parsingError, logger); logger.AssertPartialOutputStringExists(TypeScript.Analyzer.Resources.ERR_ParsingError_MissingTypescript); }
public async Task SynchronizeWithServer_UnsupportedServerVersion_StoreCleared(string versionString) { const uint cookie = 999; var sonarQubeServer = CreateSonarService(isConnected: true, serverType: ServerType.SonarQube, versionString); var taintStore = new Mock <ITaintStore>(); var monitorMock = CreateMonitorSelectionMock(cookie); var logger = new TestLogger(); var testSubject = CreateTestSubject( taintStore: taintStore.Object, sonarService: sonarQubeServer.Object, mode: SonarLintMode.Connected, vsMonitor: monitorMock.Object, logger: logger); await testSubject.SynchronizeWithServer(); logger.AssertPartialOutputStringExists("requires SonarQube v8.6 or later"); logger.AssertPartialOutputStringExists($"Connected SonarQube version: v{versionString}"); CheckIssuesAreNotFetched(sonarQubeServer); CheckStoreIsCleared(taintStore); CheckUIContextUpdated(monitorMock, cookie, 0); }
public void ProcessRequest_ExceptionInHandler_IsLoggedAndRethrown() { var testLogger = new TestLogger(logToConsole: true); const string handledRequestPath = "/path"; var context = CreateOwinContext(handledRequestPath); const string expectedErrorMessage = "exception thrown by test"; var handler = CreateHandler(handledRequestPath, processOp: () => throw new IndexOutOfRangeException(expectedErrorMessage)); var testSubject = new OwinPipelineProcessor(new[] { handler }, testLogger); Func <Task> act = () => testSubject.ProcessRequest(context.Environment); act.Should().ThrowExactly <IndexOutOfRangeException>().And.Message.Should().Be(expectedErrorMessage); CheckCorsHeader(context); testLogger.AssertPartialOutputStringExists(expectedErrorMessage); }
public async Task ProcessRequest_RecognisedPath_ReturnsStatusSetByHandler() { var testLogger = new TestLogger(logToConsole: true); const int expectedStatusCode = 12345; const string handledRequestPath = "/sonarlint/api/handled"; var context = CreateOwinContext(handledRequestPath); var handler = CreateHandler(handledRequestPath, expectedStatusCode); var testSubject = new OwinPipelineProcessor(new[] { handler }, testLogger); await testSubject.ProcessRequest(context.Environment).ConfigureAwait(false); context.Response.StatusCode.Should().Be(expectedStatusCode); CheckCorsHeader(context); testLogger.AssertPartialOutputStringExists(handledRequestPath); }
public async Task Analyze_EslintBridgeClientNotInitializedResponse_FollowedByAnotherNotInitializedResponse_GeneralParsingError() { var logger = new TestLogger(); var linterNotInitializedResponse = CreateLinterNotInitializedResponse(); var client = new Mock <IEslintBridgeClient>(); client .SetupSequence(x => x.Analyze("some path", "some config", CancellationToken.None)) .ReturnsAsync(linterNotInitializedResponse) .ReturnsAsync(linterNotInitializedResponse); var testSubject = CreateTestSubject(client.Object, logger: logger); var result = await testSubject.Analyze("some path", "some config", CancellationToken.None); logger.AssertPartialOutputStringExists(linterNotInitializedResponse.ParsingError.Message); }
public void Save_NonCriticalError_IsSquashed() { // Arrange var fileSystemMock = new Mock <IFileSystem>(); fileSystemMock.Setup(x => x.File.WriteAllText("settings.file", It.IsAny <string>())).Throws(new System.InvalidOperationException("custom error message")); var logger = new TestLogger(logToConsole: true); var testSubject = new RulesSettingsSerializer(fileSystemMock.Object, logger); // Act - should not throw testSubject.SafeSave("settings.file", new RulesSettings()); // Assert logger.AssertPartialOutputStringExists("settings.file", "custom error message"); }
public void Execute_NonCriticalError_IsSuppressed() { // Arrange var userSettingsProvider = CreateDummyUserSettingsProvider("d:\\a\\file.txt"); var testLogger = new TestLogger(); var testSubject = new TestableOpenSettingsFileWpfCommand(new ConfigurableServiceProvider(), userSettingsProvider, null, testLogger) { OpenDocOp = () => throw new InvalidOperationException("dummy execute exception") }; // Act - should not throw testSubject.Execute(null); // Assert testLogger.AssertPartialOutputStringExists("dummy execute exception"); }
public void Ctor_ErrorLoadingSettings_ErrorSquashed_AndEmptySettingsReturned() { // Arrange var fileSystemMock = new Mock <IFileSystem>(); fileSystemMock.Setup(x => x.File.Exists("settings.file")).Returns(true); fileSystemMock.Setup(x => x.File.ReadAllText("settings.file")).Throws(new System.InvalidOperationException("custom error message")); var logger = new TestLogger(logToConsole: true); // Act var testSubject = new UserSettingsProvider(logger, fileSystemMock.Object, CreateMockFileMonitor("settings.file").Object); // Assert CheckSettingsAreEmpty(testSubject.UserSettings); logger.AssertPartialOutputStringExists("custom error message"); }
public async Task ProcessRequest_InvalidServerParameter_Returns400StatusCode() { const string invalidUrl = "NOT_A_URL"; var testLogger = new TestLogger(logToConsole: true); var apiHandlerMock = new Mock <IOpenInIDERequestHandler>(); var context = CreateContext($"server={invalidUrl}&project=any&hotspot=&any"); var testSubject = new ShowHotspotOwinRequestHandler(apiHandlerMock.Object, testLogger); // Act await testSubject.ProcessRequest(context); context.Response.StatusCode.Should().Be(400); testLogger.AssertPartialOutputStringExists(invalidUrl); CheckApiHandlerNotCalled(apiHandlerMock); }