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();
}
