public static async Task Patch_NoSettings() { var mockDatabaseCommandFactory = new Mock <IDatabaseCommandFactory>(MockBehavior.Strict); var provider = new UserSettingsProvider(mockDatabaseCommandFactory.Object); await Assert.ThrowsAsync <ArgumentNullException>("userSettings", () => provider.PatchAsync(UserId, null)); }
public MainWindowViewModel(IDialogService dialogService, GitCommitsProvider gitCommitsProvider, IApplicationUiExecutor applicationUiExecutor, IUserRunConfigurationProvider userRunConfigurationProvider, UserSettingsProvider userRunSettingsProvider, IStatisticsReporter statisticsReporter, IArtefactAdapter <string, StatisticsReportData> reportArtefactAdapter, ISettingsProvider settingsProvider) { this.dialogService = dialogService; this.applicationUiExecutor = applicationUiExecutor; this.userRunConfigurationProvider = userRunConfigurationProvider; this.statisticsReporter = statisticsReporter; this.reportArtefactAdapter = reportArtefactAdapter; this.gitCommitsProvider = gitCommitsProvider; StartRunCommand = new DelegateCommand(ExecuteOfflineRunFixModel); CancelRunCommand = new DelegateCommand(CancelRun); SelectSolutionFileCommand = new DelegateCommand(SelectSolutionFile); SelectRepositoryCommand = new DelegateCommand(SelectRepository); SelectCsvTestsFileCommand = new DelegateCommand(SelectCsvTestsFile); SpecitfyIntendedChangesCommand = new DelegateCommand(SpecifyIntendedChanges); VisualizeDependenciesCommand = new DelegateCommand(VisualizeDependencies); ReportCollectedStatisticsCommand = new DelegateCommand(ReportCollectedStatistics); DiscoveryTypes = new ObservableCollection <DiscoveryType>(); ProcessingTypes = new ObservableCollection <ProcessingType>(); TestResults = new ObservableCollection <TestResultListViewItemViewModel>(); FromCommitModels = new ObservableCollection <CommitViewModel>(); ToCommitModels = new ObservableCollection <CommitViewModel>(); RunStatus = RunStatus.Ready; PropertyChanged += OnPropertyChanged; userSettings = userRunSettingsProvider.GetUserSettings(); var discoveryTypeFromSettings = userSettings.DiscoveryType; var processingTypeFromSettings = userSettings.ProcessingType; ProgramLocation = userSettings.ProgramLocation; TestType = userSettings.TestType; DiscoveryType = discoveryTypeFromSettings; ProcessingType = processingTypeFromSettings; RTSApproachType = userSettings.RTSApproachType; SolutionFilePath = userSettings.SolutionFilePath; RepositoryPath = userSettings.RepositoryPath; TimeLimit = userSettings.TimeLimit; WithTimeLimit = userSettings.WithTimeLimit; ClassNameFilter = userSettings.ClassNameFilter; TestCaseNameFilter = userSettings.TestCaseNameFilter; CategoryFilter = userSettings.CategoryFilter; CsvTestsFile = userSettings.CsvTestsFile; DiscoverNewTests = true; RegularGitsCommitRefresh(); FontSize = settingsProvider.FontSize; }
public static async Task Get_UnknownSettings() { var dataSets = new List <IDictionary <string, object> >(); var unknownSetting = new Dictionary <string, object> { { "SettingId", byte.MaxValue }, { "SettingValue", "true" } }; dataSets.Add(unknownSetting); foreach (var dataSet in CreateDataSetsForAllSettings()) { dataSets.Add(dataSet); dataSets.Add(unknownSetting); } var mockDataReader = MockDatabaseHelper.CreateMockDataReader(dataSets); var mockDatabaseCommand = MockDatabaseHelper.CreateMockDatabaseCommand(new Dictionary <string, object> { { "@UserId", UserId } }, mockDataReader.Object); var mockDatabaseCommandFactory = new Mock <IDatabaseCommandFactory>(MockBehavior.Strict); mockDatabaseCommandFactory.Setup(_ => _.Create()).Returns(mockDatabaseCommand.Object).Verifiable(); var provider = new UserSettingsProvider(mockDatabaseCommandFactory.Object); var settings = await provider.GetAsync(UserId); VerifyPopulatedSettings(settings); mockDataReader.VerifyAll(); mockDatabaseCommand.VerifyAll(); mockDatabaseCommandFactory.VerifyAll(); }
protected virtual void Deserialize(object arg) { UserSettingsProvider.Deserialize(this); // Notify that the settings were deserialized. OnDeserialized(new DataEventArgs <IUserSettings>(this)); }
public static async Task Get_InvalidSettings() { var dataSets = new List <IDictionary <string, object> >(); foreach (var dataSet in CreateDataSetsForAllSettings()) { dataSet["SettingValue"] = "SomethingInvalid"; dataSets.Add(dataSet); } var mockDataReader = MockDatabaseHelper.CreateMockDataReader(dataSets); var mockDatabaseCommand = MockDatabaseHelper.CreateMockDatabaseCommand(new Dictionary <string, object> { { "@UserId", UserId } }, mockDataReader.Object); var mockDatabaseCommandFactory = new Mock <IDatabaseCommandFactory>(MockBehavior.Strict); mockDatabaseCommandFactory.Setup(_ => _.Create()).Returns(mockDatabaseCommand.Object).Verifiable(); var provider = new UserSettingsProvider(mockDatabaseCommandFactory.Object); var settings = await provider.GetAsync(UserId); VerifyDefaultSettings(settings); mockDataReader.VerifyAll(); mockDatabaseCommand.VerifyAll(); mockDatabaseCommandFactory.VerifyAll(); }
internal UserResponse CreateResponseFromQueryResult(IBudget budget) { UserSettingsProvider userSettingsProvider = new UserSettingsProvider(this.Result.Data, this.userResultMapping.Mailbox, this.userResultMapping.CallContext.CallerCapabilities, this.userResultMapping.CallContext.UserAuthType, this.userResultMapping.CallContext.UseClientCertificateAuthentication, this.userResultMapping.CallContext.RequestedVersion, false); UserConfigurationSettings userConfigurationSettings = userSettingsProvider.GetRedirectionOrErrorSettings(); if (userConfigurationSettings == null) { userConfigurationSettings = userSettingsProvider.GetUserSettings(this.userResultMapping.CallContext.RequestedSettings, budget); } UserResponse userResponse; if (userConfigurationSettings.ErrorCode == UserConfigurationSettingsErrorCode.NoError) { userResponse = new UserResponse(); userResponse.ErrorCode = ErrorCode.NoError; userResponse.ErrorMessage = Strings.NoError; userResponse.UserSettingErrors = this.userResultMapping.CallContext.SettingErrors; userResponse.UserSettings = this.RenderUserSettings(userConfigurationSettings); } else { userResponse = ResultBase.GenerateUserResponseError(userConfigurationSettings, this.userResultMapping.CallContext.SettingErrors); } return(userResponse); }
static SettingsProvider CreateSettingsProvider() { var provider = new UserSettingsProvider("Preferences/WebGL Publisher", instance, new[] { typeof(ShareSettingsManager).Assembly }); return(provider); }
static SettingsProvider CreateSettingsProvider() { var provider = new UserSettingsProvider(k_PreferencesPath, MySettingsManager.instance, new [] { typeof(MySettingsProvider).Assembly }); return(provider); }
private static SettingsProvider CreateSettingsProvider() { var provider = new UserSettingsProvider("Preferences/Window Title", WindowTitleSettings.Instance, new[] { typeof(WindowTitleSettingsProvider).Assembly }); return(provider); }
static SettingsProvider CreateSettingsProvider() { var provider = new UserSettingsProvider(k_PreferencesPath, PolybrushSettings.instance, new[] { typeof(PolybrushSettingsProvider).Assembly }); return(provider); }
static void ProBuilderPreferencesGUI() { if (s_SettingsProvider == null) { s_SettingsProvider = new UserSettingsProvider(PolybrushSettings.instance, new[] { typeof(PolybrushSettingsProvider).Assembly }); } s_SettingsProvider.OnGUI(null); }
private static UnityEditor.SettingsProvider CreateSettingsProvider() { var provider = new UserSettingsProvider( _preferencesPath, SettingsManager.Instance, new [] { typeof(SettingsProvider).Assembly }); return(provider); }
static SettingsProvider CreateSettingsProvider() { // define project scope instead of user scope so that the editor can easily access it // assumption is that users don't create many independent unity projects anyway so that should be ok UserSettingsProvider provider = new UserSettingsProvider(preferencesPath, TravrsalSettingsManager.instance, new[] { typeof(TravrsalSettingsProvider).Assembly }, SettingsScope.Project); return(provider); }
static SettingsProvider CreateSettingsProvider() { var provider = new UserSettingsProvider(k_PreferencesPath, settings, new[] { typeof(GuidesSettingsProvider).Assembly }); settings.afterSettingsSaved += HandleUtility.Repaint; return(provider); }
public static async Task Patch_EmptySettings() { var settings = new UserSettings(); var mockDatabaseCommandFactory = new Mock <IDatabaseCommandFactory>(MockBehavior.Strict); var provider = new UserSettingsProvider(mockDatabaseCommandFactory.Object); await provider.PatchAsync(UserId, settings); mockDatabaseCommandFactory.VerifyAll(); }
public static async Task Get_NoUser() { var mockDatabaseCommandFactory = new Mock <IDatabaseCommandFactory>(MockBehavior.Strict); var provider = new UserSettingsProvider(mockDatabaseCommandFactory.Object); var settings = await provider.GetAsync(null); VerifyDefaultSettings(settings); mockDatabaseCommandFactory.VerifyAll(); }
public void SettingsChangeNotificationIsRaised() { int pause = System.Diagnostics.Debugger.IsAttached ? 20000 : 300; const string fileName = "mySettings.xxx"; // We're deliberately returning different data on each call to IFile.ReadAllText // so we can check that the provider is correctly reloading and using the file data, // and not re-using the in-memory version. const string originalData = "{}"; const string modifiedData = @"{ 'sonarlint.rules': { 'typescript:S2685': { 'level': 'on' } } }"; var fileSystemMock = CreateMockFile(fileName, originalData); var singleFileMonitorMock = CreateMockFileMonitor(fileName); int eventCount = 0; var settingsChangedEventReceived = new ManualResetEvent(initialState: false); var testSubject = new UserSettingsProvider(new TestLogger(), fileSystemMock.Object, singleFileMonitorMock.Object); testSubject.UserSettings.RulesSettings.Rules.Count.Should().Be(0); // sanity check of setup testSubject.SettingsChanged += (s, args) => { eventCount++; settingsChangedEventReceived.Set(); }; // 1. Disable a rule // Should trigger a save, but should not *directly* raise a "SettingsChanged" event testSubject.DisableRule("dummyRule"); // Timing - unfortunately, we can't reliably test for the absence of an event. We // can only wait for a certain amount of time and check no events arrive in that period. System.Threading.Thread.Sleep(pause); eventCount.Should().Be(0); // 2. Now simulate a file-change event fileSystemMock.Setup(x => x.File.ReadAllText(fileName)).Returns(modifiedData); singleFileMonitorMock.Raise(x => x.FileChanged += null, new FileSystemEventArgs(WatcherChangeTypes.Changed, "", "")); settingsChangedEventReceived.WaitOne(pause); // Check the settings change event was raised eventCount.Should().Be(1); // Check the data was actually reloaded from the file testSubject.UserSettings.RulesSettings.Rules.Count.Should().Be(1); testSubject.UserSettings.RulesSettings.Rules["typescript:S2685"].Level.Should().Be(RuleLevel.On); }
public void Ctor_NoSettingsFile_EmptySettingsReturned() { // Arrange var fileSystemMock = new Mock <IFileSystem>(); fileSystemMock.Setup(x => x.File.Exists("nonExistentFile")).Returns(false); var testLogger = new TestLogger(); // Act var testSubject = new UserSettingsProvider(testLogger, fileSystemMock.Object, CreateMockFileMonitor("nonexistentFile").Object); // Assert CheckSettingsAreEmpty(testSubject.UserSettings); testLogger.AssertOutputStringExists(AnalysisStrings.Settings_UsingDefaultSettings); }
static SettingsProvider CreateSettingsProvider() { var provider = new UserSettingsProvider(k_PreferencesPath, ProBuilderSettings.instance, new[] { typeof(ProBuilderSettingsProvider).Assembly }); ProBuilderSettings.instance.afterSettingsSaved += () => { if (ProBuilderEditor.instance != null) { ProBuilderEditor.ReloadSettings(); } }; return(provider); }
public void ConstructAndDispose() { // Arrange var fileMock = new Mock <IFile>(); var fileMonitorMock = CreateMockFileMonitor("c:\\aaa\\bbb\\file.txt"); // 1. Construct var testSubject = new UserSettingsProvider(new TestLogger(), fileMock.Object, fileMonitorMock.Object); testSubject.SettingsFilePath.Should().Be("c:\\aaa\\bbb\\file.txt"); fileMonitorMock.Verify(x => x.Dispose(), Times.Never); // 2. Dispose testSubject.Dispose(); fileMonitorMock.Verify(x => x.Dispose(), Times.Once); }
public void EnsureFileExists_NotCreatedIfExists() { // Arrange var fileMock = new Mock <IFile>(); var testSubject = new UserSettingsProvider(new TestLogger(), fileMock.Object, CreateMockFileMonitor("c:\\subDir1\\existingFile.txt").Object); fileMock.Reset(); fileMock.Setup(x => x.Exists("c:\\subDir1\\existingFile.txt")).Returns(true); // Act testSubject.EnsureFileExists(); // Assert fileMock.Verify(x => x.Exists("c:\\subDir1\\existingFile.txt"), Times.Once); fileMock.Verify(x => x.WriteAllText(It.IsAny <string>(), It.IsAny <string>()), Times.Never); }
static void ProBuilderPreferencesGUI() { if (s_SettingsProvider == null) { s_SettingsProvider = new UserSettingsProvider(ProBuilderSettings.instance, new[] { typeof(ProBuilderSettingsProvider).Assembly }); ProBuilderSettings.instance.afterSettingsSaved += () => { if (ProBuilderEditor.instance != null) { ProBuilderEditor.ReloadSettings(); } }; } s_SettingsProvider.OnGUI(null); }
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 void EnsureFileExists_CreatedIfMissing() { // Arrange const string fileName = "c:\\missingFile.txt"; var fileSystemMock = new Mock <IFileSystem>(); fileSystemMock.Setup(x => x.File.Exists(fileName)).Returns(false); var testSubject = new UserSettingsProvider(new TestLogger(), fileSystemMock.Object, CreateMockFileMonitor(fileName).Object); // Act testSubject.EnsureFileExists(); // Assert fileSystemMock.Verify(x => x.File.Exists(fileName), Times.Exactly(2)); fileSystemMock.Verify(x => x.File.WriteAllText(fileName, It.IsAny <string>()), Times.Once); }
public static async Task Patch_Success() { var settings = new UserSettings { PlayStyle = PlayStyle.Hybrid, UseScientificNotation = true, ScientificNotationThreshold = 1, UseLogarithmicGraphScale = true, LogarithmicGraphScaleThreshold = 2, HybridRatio = 3, Theme = SiteThemeType.Dark, ShouldLevelSkillAncients = true, SkillAncientBaseAncient = 4, SkillAncientLevelDiff = 5, GraphSpacingType = GraphSpacingType.Ascension, }; var parameters = new Dictionary <string, object> { { "@UserId", UserId }, { "@Value" + UserSettingsConstants.PlayStyle, settings.PlayStyle.ToString() }, { "@Value" + UserSettingsConstants.UseScientificNotation, settings.UseScientificNotation.ToString() }, { "@Value" + UserSettingsConstants.ScientificNotationThreshold, settings.ScientificNotationThreshold.ToString() }, { "@Value" + UserSettingsConstants.UseLogarithmicGraphScale, settings.UseLogarithmicGraphScale.ToString() }, { "@Value" + UserSettingsConstants.LogarithmicGraphScaleThreshold, settings.LogarithmicGraphScaleThreshold.ToString() }, { "@Value" + UserSettingsConstants.HybridRatio, settings.HybridRatio.ToString() }, { "@Value" + UserSettingsConstants.Theme, settings.Theme.ToString() }, { "@Value" + UserSettingsConstants.ShouldLevelSkillAncients, settings.ShouldLevelSkillAncients.ToString() }, { "@Value" + UserSettingsConstants.SkillAncientBaseAncient, settings.SkillAncientBaseAncient.ToString() }, { "@Value" + UserSettingsConstants.SkillAncientLevelDiff, settings.SkillAncientLevelDiff.ToString() }, { "@Value" + UserSettingsConstants.GraphSpacingType, settings.GraphSpacingType.ToString() }, }; var mockDatabaseCommand = MockDatabaseHelper.CreateMockDatabaseCommand(parameters); var mockDatabaseCommandFactory = new Mock <IDatabaseCommandFactory>(MockBehavior.Strict); mockDatabaseCommandFactory.Setup(_ => _.Create()).Returns(mockDatabaseCommand.Object).Verifiable(); var provider = new UserSettingsProvider(mockDatabaseCommandFactory.Object); await provider.PatchAsync(UserId, settings); mockDatabaseCommand.VerifyAll(); mockDatabaseCommandFactory.VerifyAll(); }
public static async Task Get_MissingSettings() { var mockDataReader = MockDatabaseHelper.CreateMockDataReader(); var mockDatabaseCommand = MockDatabaseHelper.CreateMockDatabaseCommand(new Dictionary <string, object> { { "@UserId", UserId } }, mockDataReader.Object); var mockDatabaseCommandFactory = new Mock <IDatabaseCommandFactory>(MockBehavior.Strict); mockDatabaseCommandFactory.Setup(_ => _.Create()).Returns(mockDatabaseCommand.Object).Verifiable(); var provider = new UserSettingsProvider(mockDatabaseCommandFactory.Object); var settings = await provider.GetAsync(UserId); VerifyDefaultSettings(settings); mockDataReader.VerifyAll(); mockDatabaseCommand.VerifyAll(); mockDatabaseCommandFactory.VerifyAll(); }
public void FileChanges_EventsRaised() { var fileSystemMock = new Mock <IFileSystem>(); fileSystemMock.Setup(x => x.File.Exists("settings.file")).Returns(true); var fileMonitorMock = CreateMockFileMonitor("settings.file"); int settingsChangedEventCount = 0; const string invalidSettingsData = "NOT VALID JSON"; const string validSettingsData = @"{ 'sonarlint.rules': { 'typescript:S2685': { 'level': 'on' } } }"; var logger = new TestLogger(); var testSubject = new UserSettingsProvider(logger, fileSystemMock.Object, fileMonitorMock.Object); testSubject.SettingsChanged += (s, args) => settingsChangedEventCount++; logger.Reset(); // 1. Simulate the file change when the file is invalid fileSystemMock.Setup(x => x.File.ReadAllText("settings.file")).Returns(invalidSettingsData); fileMonitorMock.Raise(x => x.FileChanged += null, new FileSystemEventArgs(WatcherChangeTypes.Changed, "", "")); // Assert settingsChangedEventCount.Should().Be(1); CheckSettingsAreEmpty(testSubject.UserSettings); // 2. Simulate another event when the file is valid - valid settings should be returned fileSystemMock.Setup(x => x.File.ReadAllText("settings.file")).Returns(validSettingsData); fileMonitorMock.Raise(x => x.FileChanged += null, new FileSystemEventArgs(WatcherChangeTypes.Changed, "", "")); // Assert settingsChangedEventCount.Should().Be(2); testSubject.UserSettings.Should().NotBeNull(); testSubject.UserSettings.RulesSettings.Should().NotBeNull(); testSubject.UserSettings.RulesSettings.Rules.Should().NotBeNull(); testSubject.UserSettings.RulesSettings.Rules.Count.Should().Be(1); }
public void RealFile_DisablePreviouslyEnabledRule() { var dir = CreateTestSpecificDirectory(); var settingsFile = Path.Combine(dir, "settings.txt"); var initialSettings = new RulesSettings { Rules = new System.Collections.Generic.Dictionary <string, RuleConfig> { { "javascript:S111", new RuleConfig { Level = RuleLevel.On } }, { "cpp:S111", new RuleConfig { Level = RuleLevel.On } }, { "xxx:S222", new RuleConfig { Level = RuleLevel.On } } } }; SaveSettings(settingsFile, initialSettings); var testLogger = new TestLogger(logToConsole: true); var testSubject = new UserSettingsProvider(testLogger, new FileSystem(), new SingleFileMonitor(settingsFile, testLogger)); // Sanity check of test setup testSubject.UserSettings.RulesSettings.Rules.Count.Should().Be(3); // Act - Disable a rule testSubject.DisableRule("cpp:S111"); // Check the data on disc File.Exists(settingsFile).Should().BeTrue(); var reloadedSettings = LoadSettings(settingsFile); reloadedSettings.Rules.Count.Should().Be(3); reloadedSettings.Rules["javascript:S111"].Level.Should().Be(RuleLevel.On); reloadedSettings.Rules["cpp:S111"].Level.Should().Be(RuleLevel.Off); reloadedSettings.Rules["xxx:S222"].Level.Should().Be(RuleLevel.On); }
public void EnsureFileExists_NotCreatedIfExists() { // Arrange const string fileName = "c:\\subDir1\\existingFile.txt"; var fileSystemMock = new Mock <IFileSystem>(); fileSystemMock.Setup(x => x.File.Exists(fileName)).Returns(true); var testSubject = new UserSettingsProvider(new TestLogger(), fileSystemMock.Object, CreateMockFileMonitor(fileName).Object); fileSystemMock.Invocations.Clear(); // Act testSubject.EnsureFileExists(); // Assert fileSystemMock.Verify(x => x.File.Exists(fileName), Times.Exactly(2)); fileSystemMock.Verify(x => x.File.WriteAllText(It.IsAny <string>(), It.IsAny <string>()), Times.Never); }
public void ConstructAndDispose() { const string fileName = "c:\\aaa\\bbb\\file.txt"; // Arrange var fileSystemMock = new Mock <IFileSystem>(); fileSystemMock.Setup(x => x.File.Exists(fileName)).Returns(false); var fileMonitorMock = CreateMockFileMonitor(fileName); // 1. Construct var testSubject = new UserSettingsProvider(new TestLogger(), fileSystemMock.Object, fileMonitorMock.Object); testSubject.SettingsFilePath.Should().Be(fileName); fileMonitorMock.Verify(x => x.Dispose(), Times.Never); // 2. Dispose testSubject.Dispose(); fileMonitorMock.Verify(x => x.Dispose(), Times.Once); }
public void TestInitialize() { _provider = new UserSettingsProvider(); }