public void DisablingCustomPackagePathsCorrectlyDisablesLoading()
{
//setup clean loader where std lib is a custom package path
var loader = new PackageLoader(new[] { StandardLibraryTestDirectory }, string.Empty);
var settings = new PreferenceSettings();
//disable custom package paths
settings.DisableCustomPackageLocations = true;
settings.CustomPackageFolders = new List <string>()
{
StandardLibraryTestDirectory
};
var loaderParams = new LoadPackageParams()
{
PathManager = CurrentDynamoModel.PathManager,
Preferences = settings
};
//invoke the load
loader.LoadAll(loaderParams);
//assert the package in the custom package path was not loaded
Assert.IsFalse(loader.LocalPackages.Any(x => x.BinaryDirectory.Contains("SignedPackage2")));
Assert.AreEqual(0, loader.LocalPackages.Count());
}
public void LoadInvalidLocationsFromSetting()
{
var filePath = Path.Combine(SettingDirectory, "DynamoSettings-invalidPaths.xml");
// check files required for test exist
Assert.IsTrue(File.Exists(filePath));
// load the settings from XML file into DynamoModel
var settings = PreferenceSettings.Load(filePath);
// check settings were read correctly
Assert.NotNull(settings);
Assert.AreEqual(4, settings.CustomPackageFolders.Count);
var expectedPackageFolders = new List <string> {
@"C:\folder_name_with_invalid_:*?|_characters\foobar",
@"C:\this_folder_doesn't_exist",
@"X:\this_drive_doesn't_exist",
@"\\unreachable_machine\share_packages"
};
IEnumerable <bool> comparisonResult = settings.CustomPackageFolders.Zip(expectedPackageFolders, string.Equals);
Assert.IsFalse(comparisonResult.Any(isEqual => !isEqual));
}
public DynamoAnalyticsTests()
{
dynamoSettings = new PreferenceSettings()
{
IsAnalyticsReportingApproved = true, IsUsageReportingApproved = true
};
}
public void AddRemovePathsTest()
{
var setting = new PreferenceSettings()
{
CustomPackageFolders = { @"Z:\" }
};
var vm = new PackagePathViewModel(setting);
var path = string.Empty;
vm.RequestShowFileDialog += (sender, args) => { args.Path = path; };
path = @"C:\";
vm.AddPathCommand.Execute(null);
path = @"D:\";
vm.AddPathCommand.Execute(null);
Assert.AreEqual(0, vm.SelectedIndex);
Assert.AreEqual(@"C:\", vm.RootLocations[1]);
Assert.AreEqual(@"D:\", vm.RootLocations[2]);
vm.SelectedIndex = 2;
vm.DeletePathCommand.Execute(0);
Assert.AreEqual(1, vm.SelectedIndex);
Assert.AreEqual(@"C:\", vm.RootLocations[0]);
Assert.AreEqual(@"D:\", vm.RootLocations[1]);
}
public void PreferenceSetting_GroupStyles()
{
// Test that thte group style list is being initialized with an empty list
Assert.NotNull(ViewModel.PreferenceSettings.GroupStyleItemsList);
Assert.AreEqual(0, ViewModel.PreferenceSettings.GroupStyleItemsList.Count);
// Test serialization of GroupStyles
string tempPath = System.IO.Path.GetTempPath();
tempPath = Path.Combine(tempPath, "userPreference.xml");
PreferenceSettings initalSetting = new PreferenceSettings();
PreferenceSettings resultSetting;
initalSetting.GroupStyleItemsList.Add(new GroupStyleItem {
HexColorString = "000000",
Name = "GroupName"
});
initalSetting.Save(tempPath);
resultSetting = PreferenceSettings.Load(tempPath);
// Test if the fields are being saved
Assert.AreEqual(1, initalSetting.GroupStyleItemsList.Count);
Assert.AreEqual(resultSetting.GroupStyleItemsList[0].Name, initalSetting.GroupStyleItemsList[0].Name);
Assert.AreEqual(resultSetting.GroupStyleItemsList[0].HexColorString, initalSetting.GroupStyleItemsList[0].HexColorString);
// Test loading the settings defined in the xml configuration file
var filePath = Path.Combine(GetTestDirectory(ExecutingDirectory), @"settings\DynamoSettings-OneGroupStyle.xml");
PreferenceSettings OneGroupStyle = PreferenceSettings.Load(filePath);
Assert.AreEqual(1, OneGroupStyle.GroupStyleItemsList.Count);
Assert.AreEqual(OneGroupStyle.GroupStyleItemsList[0].Name, initalSetting.GroupStyleItemsList[0].Name);
Assert.AreEqual(OneGroupStyle.GroupStyleItemsList[0].HexColorString, initalSetting.GroupStyleItemsList[0].HexColorString);
}
public void EnableCustomPackagePathsLoadsPackagesOnClosingPreferences()
{
var setting = new PreferenceSettings()
{
CustomPackageFolders = { PackagesDirectory }
};
var vm = CreatePackagePathViewModel(setting);
var libraryLoader = new ExtensionLibraryLoader(ViewModel.Model);
vm.packageLoader.PackagesLoaded += libraryLoader.LoadPackages;
vm.packageLoader.RequestLoadNodeLibrary += libraryLoader.LoadLibraryAndSuppressZTSearchImport;
(setting as IDisablePackageLoadingPreferences).DisableCustomPackageLocations = true;
// Load packages in package path.
vm.packageLoader.LoadAll(vm.loadPackageParams);
Assert.AreEqual(0, vm.packageLoader.LocalPackages.Count());
// simulate turning off "disable custom package paths" toggle.
vm.SetPackagesScheduledState(setting.CustomPackageFolders.First(), false);
// simulate closing preferences dialog by saving changes to packagepathviewmodel
vm.SaveSettingCommand.Execute(null);
// packages are expected to load from 'PackagesDirectory' above when toggle is turned off
Assert.AreEqual(19, vm.packageLoader.LocalPackages.Count());
vm.packageLoader.PackagesLoaded -= libraryLoader.LoadPackages;
vm.packageLoader.RequestLoadNodeLibrary -= libraryLoader.LoadLibraryAndSuppressZTSearchImport;
}
private static void MakeStandaloneAndRun(string commandFilePath, ref DynamoViewModel viewModel)
{
DynamoPathManager.Instance.InitializeCore(
Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location));
DynamoPathManager.PreloadAsmLibraries(DynamoPathManager.Instance);
var model = DynamoModel.Start(
new DynamoModel.StartConfiguration()
{
Preferences = PreferenceSettings.Load()
});
viewModel = DynamoViewModel.Start(
new DynamoViewModel.StartConfiguration()
{
CommandFilePath = commandFilePath,
DynamoModel = model
});
var view = new DynamoView(viewModel);
var app = new Application();
app.Run(view);
}
public void ReorderingPathsTest()
{
var setting = new PreferenceSettings
{
CustomPackageFolders = { @"C:\", @"D:\", @"E:\" }
};
var vm = CreatePackagePathViewModel(setting);
Assert.IsTrue(vm.MovePathDownCommand.CanExecute(0));
Assert.IsFalse(vm.MovePathUpCommand.CanExecute(0));
Assert.IsTrue(vm.MovePathUpCommand.CanExecute(2));
Assert.IsFalse(vm.MovePathDownCommand.CanExecute(2));
Assert.IsTrue(vm.MovePathUpCommand.CanExecute(1));
Assert.IsTrue(vm.MovePathDownCommand.CanExecute(1));
vm.MovePathUpCommand.Execute(1);
Assert.AreEqual(@"D:\", vm.RootLocations[0]);
Assert.AreEqual(@"C:\", vm.RootLocations[1]);
Assert.AreEqual(@"E:\", vm.RootLocations[2]);
vm.MovePathDownCommand.Execute(1);
Assert.AreEqual(@"D:\", vm.RootLocations[0]);
Assert.AreEqual(@"E:\", vm.RootLocations[1]);
Assert.AreEqual(@"C:\", vm.RootLocations[2]);
}
public override void Setup()
{
base.Setup();
var settings = new PreferenceSettings();
var parentFolder = Path.Combine(TestDirectory, "pkgs", "multiple_locations");
settings.CustomPackageFolders = new List <string>
{
Path.Combine(parentFolder, "folder1"),
@"C:\folder_name_with_invalid_:*?|_characters\foobar",
@"C:\this_folder_doesn't_exist",
Path.Combine(parentFolder, "folder2"),
@"X:\this_drive_doesn't_exist",
@"\\unreachable_machine\share_packages",
Path.Combine(parentFolder, "folder3")
};
var settingFilePath = Path.Combine(TempFolder, "DynamoSettings.xml");
settings.Save(settingFilePath);
var settingsLoadedFromFile = PreferenceSettings.Load(settingFilePath);
StartDynamo(settingsLoadedFromFile);
}
public void PreferenceSetting_RenderPrecision()
{
// Test that RenderPrecision setting works as expected
ViewModel.RenderPackageFactoryViewModel.MaxTessellationDivisions = 256;
Assert.AreEqual(256, ViewModel.Model.PreferenceSettings.RenderPrecision);
ViewModel.RenderPackageFactoryViewModel.MaxTessellationDivisions = 128;
Assert.AreEqual(128, ViewModel.Model.PreferenceSettings.RenderPrecision);
// Test serialization of RenderPrecision
string tempPath = System.IO.Path.GetTempPath();
tempPath = Path.Combine(tempPath, "userPreference.xml");
PreferenceSettings initalSetting = new PreferenceSettings();
PreferenceSettings resultSetting;
initalSetting.RenderPrecision = 256;
initalSetting.Save(tempPath);
resultSetting = PreferenceSettings.Load(tempPath);
Assert.AreEqual(resultSetting.RenderPrecision, initalSetting.RenderPrecision);
// Test loading old settings file without render precision attribute
var filePath = Path.Combine(GetTestDirectory(ExecutingDirectory), @"settings\DynamoSettings-WithoutRenderPrecision.xml");
PreferenceSettings WithoutRenderPrecision = PreferenceSettings.Load(filePath);
Assert.AreEqual(WithoutRenderPrecision.RenderPrecision, 128);
}
/// <summary>
/// Migrates preference settings, packages, custom node definitions, etc.
/// from source migrator version to current version.
/// This function can be overridden by version specific migrator classes
/// </summary>
/// <param name="sourceMigrator"> source migrator version from which to migrate from </param>
/// /// <returns>new migrator instance after migration</returns>
protected virtual DynamoMigratorBase MigrateFrom(DynamoMigratorBase sourceMigrator)
{
Copy(sourceMigrator.PackagesDirectory, PackagesDirectory);
Copy(sourceMigrator.DefinitionsDirectory, DefinitionsDirectory);
PreferenceSettings = sourceMigrator.PreferenceSettings;
if (PreferenceSettings == null)
{
return(this);
}
// All preference settings are copied over including custom package folders
// However if one of the custom folder locations points to the user data directory
// of the previous version, it needs to be replaced with that of the current version
var folders = PreferenceSettings.CustomPackageFolders;
var indexToReplace = folders.FindIndex(f => f.Contains(sourceMigrator.UserDataDirectory));
if (indexToReplace <= -1)
{
return(this);
}
folders.RemoveAt(indexToReplace);
folders.Insert(indexToReplace, UserDataDirectory);
return(this);
}
public void PreferenceSettingsConnectorTypeRevertsToBezier()
{
// Arrange
var preferences = new PreferenceSettings()
{
ConnectorType = ConnectorType.POLYLINE
};
var config = new DynamoModel.DefaultStartConfiguration()
{
PathResolver = pathResolver,
StartInTestMode = true,
ProcessMode = TaskProcessMode.Synchronous,
Preferences = preferences,
};
// Act
RestartTestSetupWithNewSettings(config, true);
// Assert
// Check that prefferenceSettings are set to ConnectorType.POLYLINE
// but the Models connector type is BEZIER
Assert.That(Model.PreferenceSettings.ConnectorType == ConnectorType.POLYLINE);
Assert.That(Model.ConnectorType == ConnectorType.BEZIER);
}
public override void Setup()
{
base.Setup();
libraryCore = new ProtoCore.Core(new Options());
libraryCore.Compilers.Add(Language.Associative, new ProtoAssociative.Compiler(libraryCore));
libraryCore.Compilers.Add(Language.Imperative, new ProtoImperative.Compiler(libraryCore));
libraryCore.ParsingMode = ParseMode.AllowNonAssignment;
var pathResolver = new TestPathResolver();
pathResolver.AddPreloadLibraryPath("Builtin.dll");
pathResolver.AddPreloadLibraryPath("DSCoreNodes.dll");
var pathManager = new PathManager(new PathManagerParams
{
PathResolver = pathResolver
});
var settings = new PreferenceSettings();
libraryServices = new LibraryServices(libraryCore, pathManager, settings);
RegisterEvents();
}
private static RevitDynamoModel InitializeCoreModel(ExternalCommandData commandData)
{
var prefs = PreferenceSettings.Load();
var corePath =
Path.GetFullPath(
Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) + @"\..\");
#if !ENABLE_DYNAMO_SCHEDULER
return(RevitDynamoModel.Start(
new RevitDynamoModel.StartConfiguration()
{
Preferences = prefs,
DynamoCorePath = corePath,
Context = GetRevitContext(commandData)
}));
#else
return(RevitDynamoModel.Start(
new RevitDynamoModel.StartConfiguration()
{
Preferences = prefs,
DynamoCorePath = corePath,
Context = GetRevitContext(commandData),
SchedulerThread = new RevitSchedulerThread(commandData.Application)
}));
#endif
}
public void AddRemovePathsTest()
{
var setting = new PreferenceSettings()
{
CustomPackageFolders = { @"Z:\" }
};
var vm = new PackagePathViewModel(setting);
var path = string.Empty;
vm.RequestShowFileDialog += (sender, args) => { args.Path = path; };
path = @"C:\";
vm.AddPathCommand.Execute(null);
path = @"D:\";
vm.AddPathCommand.Execute(null);
Assert.AreEqual(0, vm.SelectedIndex);
Assert.AreEqual(@"C:\", vm.RootLocations[1]);
Assert.AreEqual(@"D:\", vm.RootLocations[2]);
vm.SelectedIndex = 2;
vm.DeletePathCommand.Execute(0);
Assert.AreEqual(1, vm.SelectedIndex);
Assert.AreEqual(@"C:\", vm.RootLocations[0]);
Assert.AreEqual(@"D:\", vm.RootLocations[1]);
}
/// <summary>
/// Migrates preference settings, packages, custom node definitions, etc.
/// from source migrator version to current version.
/// This function can be overridden by version specific migrator classes
/// </summary>
/// <param name="sourceMigrator"> source migrator version from which to migrate from </param>
/// /// <returns>new migrator instance after migration</returns>
protected virtual DynamoMigratorBase MigrateFrom(DynamoMigratorBase sourceMigrator)
{
Copy(sourceMigrator.PackagesDirectory, this.PackagesDirectory);
Copy(sourceMigrator.DefinitionsDirectory, this.DefinitionsDirectory);
this.PreferenceSettings = sourceMigrator.PreferenceSettings;
return(this);
}
/// <summary>
/// The PreferencesViewModel constructor basically initialize all the ItemsSource for the corresponding ComboBox in the View (PreferencesView.xaml)
/// </summary>
public PreferencesViewModel(PreferenceSettings preferenceSettings, DynamoPythonScriptEditorTextOptions editTextOptions)
{
this.preferenceSettings = preferenceSettings;
this.pythonScriptEditorTextOptions = editTextOptions;
PythonEnginesList = new ObservableCollection <string>();
PythonEnginesList.Add(Wpf.Properties.Resources.DefaultPythonEngineNone);
AddPythonEnginesOptions();
SelectedPythonEngine = preferenceSettings.DefaultPythonEngine;
string languages = Wpf.Properties.Resources.PreferencesWindowLanguages;
LanguagesList = new ObservableCollection <string>(languages.Split(','));
SelectedLanguage = languages.Split(',').First();
FontSizeList = new ObservableCollection <string>();
FontSizeList.Add(Wpf.Properties.Resources.ScalingSmallButton);
FontSizeList.Add(Wpf.Properties.Resources.ScalingMediumButton);
FontSizeList.Add(Wpf.Properties.Resources.ScalingLargeButton);
FontSizeList.Add(Wpf.Properties.Resources.ScalingExtraLargeButton);
SelectedFontSize = Wpf.Properties.Resources.ScalingMediumButton;
NumberFormatList = new ObservableCollection <string>();
NumberFormatList.Add(Wpf.Properties.Resources.DynamoViewSettingMenuNumber0);
NumberFormatList.Add(Wpf.Properties.Resources.DynamoViewSettingMenuNumber00);
NumberFormatList.Add(Wpf.Properties.Resources.DynamoViewSettingMenuNumber000);
NumberFormatList.Add(Wpf.Properties.Resources.DynamoViewSettingMenuNumber0000);
NumberFormatList.Add(Wpf.Properties.Resources.DynamoViewSettingMenuNumber00000);
SelectedNumberFormat = Wpf.Properties.Resources.DynamoViewSettingMenuNumber0000;
//By Default the Default Run Settings radio button will be in Manual
RunSettingsIsChecked = true;
//By Default the warning state of the Visual Settings tab (Group Styles section) will be disabled
isWarningEnabled = false;
StyleItemsList = new ObservableCollection <StyleItem>();
//When pressing the "Add Style" button some controls will be shown with some values by default so later they can be populated by the user
AddStyleControl = new StyleItem()
{
GroupName = "", HexColorString = "#" + GetRandomHexStringColor()
};
//This piece of code will populate all the description text for the RadioButtons in the Geometry Scaling section.
optionsGeometryScal = new GeometryScalingOptions();
optionsGeometryScal.EnumProperty = GeometryScaleSize.Medium;
optionsGeometryScal.DescriptionScaleRange = new ObservableCollection <string>();
optionsGeometryScal.DescriptionScaleRange.Add(string.Format(Res.ChangeScaleFactorPromptDescriptionContent, scaleRanges[GeometryScaleSize.Small].Item2,
scaleRanges[GeometryScaleSize.Small].Item3));
optionsGeometryScal.DescriptionScaleRange.Add(string.Format(Res.ChangeScaleFactorPromptDescriptionContent, scaleRanges[GeometryScaleSize.Medium].Item2,
scaleRanges[GeometryScaleSize.Medium].Item3));
optionsGeometryScal.DescriptionScaleRange.Add(string.Format(Res.ChangeScaleFactorPromptDescriptionContent, scaleRanges[GeometryScaleSize.Large].Item2,
scaleRanges[GeometryScaleSize.Large].Item3));
optionsGeometryScal.DescriptionScaleRange.Add(string.Format(Res.ChangeScaleFactorPromptDescriptionContent, scaleRanges[GeometryScaleSize.ExtraLarge].Item2,
scaleRanges[GeometryScaleSize.ExtraLarge].Item3));
}
public PackageValidationTest()
{
dynamoSettings = new PreferenceSettings()
{
CustomPackageFolders = new List <string>()
{
Path.Combine(TestDirectory, @"core\userdata\0.8")
}
};
}
public void PreferenceSetting_AgreeAnalyticsSharing()
{
// Test loading old settings file with agreement
var filePath = Path.Combine(GetTestDirectory(ExecutingDirectory), @"settings\DynamoSettings-AnalyticsTurnedOn.xml");
var resultSetting = PreferenceSettings.Load(filePath);
Assert.AreEqual(true, resultSetting.IsAnalyticsReportingApproved);
Assert.AreEqual(false, resultSetting.IsUsageReportingApproved);
Assert.DoesNotThrow(() => Dynamo.Logging.AnalyticsService.ShutDown());
}
public void CannotDeletePathIfThereIsOnlyOne()
{
var setting = new PreferenceSettings
{
CustomPackageFolders = { @"C:\" }
};
var vm = new PackagePathViewModel(setting);
Assert.AreEqual(1, vm.RootLocations.Count);
Assert.IsFalse(vm.DeletePathCommand.CanExecute(null));
}
private PackagePathViewModel CreatePackagePathViewModel(PreferenceSettings setting)
{
PackageLoader loader = new PackageLoader(setting.CustomPackageFolders);
LoadPackageParams loadParams = new LoadPackageParams
{
Preferences = setting,
PathManager = Model.PathManager
};
CustomNodeManager customNodeManager = Model.CustomNodeManager;
return new PackagePathViewModel(loader, loadParams, customNodeManager);
}
public void CannotDeletePathIfThereIsOnlyOne()
{
var setting = new PreferenceSettings
{
CustomPackageFolders = { @"C:\" }
};
var vm = new PackagePathViewModel(setting);
Assert.AreEqual(1, vm.RootLocations.Count);
Assert.IsFalse(vm.DeletePathCommand.CanExecute(null));
}
public SettingsViewModel()
{
preferenceSettings = PreferenceSettings.Instance;
soundService = DependencyService.Get <ISoundService>();
Title = "Settings";
preferenceSettings.OnCpmChanged += (object sender, EventArgs e) => OnPropertyChanged("Cpm");
preferenceSettings.OnVolumeChanged += (object sender, EventArgs e) => OnPropertyChanged("AutoSetVolume");
preferenceSettings.OnStartEndHistoryChanged += (object sender, EventArgs e) => OnPropertyChanged("StartEndHistory");
}
public void IfPathsAreUnchangedPackagesAreNotReloaded()
{
var count = 0;
var setting = new PreferenceSettings()
{
CustomPackageFolders = { @"Z:\" }
};
var pathManager = new Mock <IPathManager>();
pathManager.SetupGet(x => x.PackagesDirectories).Returns(
() => setting.CustomPackageFolders);
PackageLoader loader = new PackageLoader(pathManager.Object);
loader.PackagesLoaded += Loader_PackagesLoaded;
LoadPackageParams loadParams = new LoadPackageParams
{
Preferences = setting,
};
CustomNodeManager customNodeManager = Model.CustomNodeManager;
var vm = new PackagePathViewModel(loader, loadParams, customNodeManager);
vm.SaveSettingCommand.Execute(null);
//should not have reloaded anything.
Assert.AreEqual(0, count);
var path = string.Empty;
vm.RequestShowFileDialog += (sender, args) => { args.Path = path; };
path = Path.Combine(GetTestDirectory(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location)), "pkgs");
//add the new path
vm.AddPathCommand.Execute(null);
//save the new path
vm.SaveSettingCommand.Execute(null);
//should have loaded something.
Assert.AreEqual(10, count);
//commit the paths again.
vm.SaveSettingCommand.Execute(null);
//should not have loaded anything.
Assert.AreEqual(10, count);
void Loader_PackagesLoaded(System.Collections.Generic.IEnumerable <Assembly> obj)
{
count = count + obj.Count();
}
loader.PackagesLoaded -= Loader_PackagesLoaded;
}
public void TestSettingsSerialization()
{
string tempPath = System.IO.Path.GetTempPath();
tempPath = Path.Combine(tempPath, "userPreference.xml");
PreferenceSettings settings = new PreferenceSettings();
// Assert defaults
Assert.AreEqual(settings.GetIsBackgroundPreviewActive("MyBackgroundPreview"), true);
Assert.AreEqual(settings.ShowCodeBlockLineNumber, true);
Assert.AreEqual(settings.IsIronPythonDialogDisabled, false);
Assert.AreEqual(settings.ShowTabsAndSpacesInScriptEditor, false);
Assert.AreEqual(settings.EnableNodeAutoComplete, false);
Assert.AreEqual(settings.DefaultPythonEngine, string.Empty);
Assert.AreEqual(settings.MaxNumRecentFiles, PreferenceSettings.DefaultMaxNumRecentFiles);
// Save
settings.Save(tempPath);
settings = PreferenceSettings.Load(tempPath);
// Assert deserialized values are same when saved with defaults
Assert.AreEqual(settings.GetIsBackgroundPreviewActive("MyBackgroundPreview"), true);
Assert.AreEqual(settings.ShowCodeBlockLineNumber, true);
Assert.AreEqual(settings.IsIronPythonDialogDisabled, false);
Assert.AreEqual(settings.ShowTabsAndSpacesInScriptEditor, false);
Assert.AreEqual(settings.EnableNodeAutoComplete, false);
Assert.AreEqual(settings.DefaultPythonEngine, string.Empty);
Assert.AreEqual(settings.MaxNumRecentFiles, PreferenceSettings.DefaultMaxNumRecentFiles);
// Change setting values
settings.SetIsBackgroundPreviewActive("MyBackgroundPreview", false);
settings.ShowCodeBlockLineNumber = false;
settings.IsIronPythonDialogDisabled = true;
settings.ShowTabsAndSpacesInScriptEditor = true;
settings.DefaultPythonEngine = "CP3";
settings.MaxNumRecentFiles = 24;
settings.EnableNodeAutoComplete = true;
// Save
settings.Save(tempPath);
settings = PreferenceSettings.Load(tempPath);
// Assert deserialized values are same as last changed
Assert.AreEqual(settings.GetIsBackgroundPreviewActive("MyBackgroundPreview"), false);
Assert.AreEqual(settings.ShowCodeBlockLineNumber, false);
Assert.AreEqual(settings.IsIronPythonDialogDisabled, true);
Assert.AreEqual(settings.ShowTabsAndSpacesInScriptEditor, true);
Assert.AreEqual(settings.DefaultPythonEngine, "CP3");
Assert.AreEqual(settings.MaxNumRecentFiles, 24);
Assert.AreEqual(settings.EnableNodeAutoComplete, true);
}
public void UsageReportingApprovedSetting()
{
var settings = new PreferenceSettings();
Assert.IsFalse(settings.IsUsageReportingApproved);
// Check when deserializing preference setting with first run flag
var settingFilePath = Path.Combine(SettingDirectory, "DynamoSettings-firstrun.xml");
var settingsFromXML = PreferenceSettings.Load(settingFilePath);
Assert.IsTrue(settingsFromXML.IsFirstRun);
Assert.IsFalse(settingsFromXML.IsUsageReportingApproved);
}
public void CannotUpdateStandardLibraryPath()
{
var setting = new PreferenceSettings
{
CustomPackageFolders = { @"%StandardLibrary%", @"C:\" }
};
var vm = CreatePackagePathViewModel(setting);
Assert.AreEqual(2, vm.RootLocations.Count);
Assert.IsFalse(vm.UpdatePathCommand.CanExecute(null));
}
public void TestLoad()
{
string settingDirectory = Path.Combine(TestDirectory, "settings");
string settingsFilePath = Path.Combine(settingDirectory, "DynamoSettings-PythonTemplate-initial.xml");
string initialPyFilePath = Path.Combine(settingDirectory, @"PythonTemplate-initial.py");
// Assert files required for test exist
Assert.IsTrue(File.Exists(settingsFilePath));
var settings = PreferenceSettings.Load(settingsFilePath);
Assert.IsNotNull(settings);
}
public void CannotUpdateProgramDataPath()
{
var setting = new PreferenceSettings
{
CustomPackageFolders = { Path.Combine(ViewModel.Model.PathManager.CommonDataDirectory, "Packages"), @"C:\" }
};
var vm = CreatePackagePathViewModel(setting);
Assert.AreEqual(2, vm.RootLocations.Count);
Assert.IsFalse(vm.UpdatePathCommand.CanExecute(0));
Assert.IsTrue(vm.UpdatePathCommand.CanExecute(1));
}
public void CannotUpdateBuiltinPackagesPath()
{
var setting = new PreferenceSettings
{
CustomPackageFolders = { DynamoModel.BuiltInPackagesToken, @"C:\" }
};
var vm = CreatePackagePathViewModel(setting);
Assert.AreEqual(2, vm.RootLocations.Count);
Assert.IsFalse(vm.UpdatePathCommand.CanExecute(0));
Assert.IsTrue(vm.UpdatePathCommand.CanExecute(1));
}
/// <summary>
/// Migrates preference settings, customized migration step in derived class.
/// from source migrator version to current version.
/// This function can be overridden by version specific migrator classes
/// </summary>
/// <param name="sourceMigrator"> source migrator version from which to migrate from </param>
/// <returns>new migrator instance after migration</returns>
protected virtual DynamoMigratorBase MigrateFrom(DynamoMigratorBase sourceMigrator)
{
PreferenceSettings = sourceMigrator.PreferenceSettings;
if (PreferenceSettings == null)
{
return(this);
}
// All preference settings are copied over except for custom package folders
PreferenceSettings.CustomPackageFolders.Clear();
PreferenceSettings.CustomPackageFolders.Insert(0, UserDataDirectory);
return(this);
}
public void TestMigrateStdLibTokenToBuiltInToken()
{
string settingDirectory = Path.Combine(TestDirectory, "settings");
string settingsFilePath = Path.Combine(settingDirectory, "DynamoSettings-stdlibtoken.xml");
Assert.IsTrue(File.ReadAllText(settingsFilePath).Contains(DynamoModel.StandardLibraryToken));
// Assert files required for test exist
Assert.IsTrue(File.Exists(settingsFilePath));
var settings = PreferenceSettings.Load(settingsFilePath);
var token = settings.CustomPackageFolders[1];
Assert.AreEqual(DynamoModel.BuiltInPackagesToken, token);
}
public void ReorderingPathsTest()
{
var setting = new PreferenceSettings
{
CustomPackageFolders = { @"C:\", @"D:\", @"E:\" }
};
var vm = new PackagePathViewModel(setting);
Assert.AreEqual(0, vm.SelectedIndex);
Assert.IsTrue(vm.MovePathDownCommand.CanExecute(null));
Assert.IsFalse(vm.MovePathUpCommand.CanExecute(null));
vm.SelectedIndex = 2;
Assert.AreEqual(2, vm.SelectedIndex);
Assert.IsTrue(vm.MovePathUpCommand.CanExecute(null));
Assert.IsFalse(vm.MovePathDownCommand.CanExecute(null));
vm.SelectedIndex = 1;
Assert.AreEqual(1, vm.SelectedIndex);
Assert.IsTrue(vm.MovePathUpCommand.CanExecute(null));
Assert.IsTrue(vm.MovePathDownCommand.CanExecute(null));
vm.MovePathUpCommand.Execute(vm.SelectedIndex);
Assert.AreEqual(0, vm.SelectedIndex);
Assert.AreEqual(@"D:\", vm.RootLocations[0]);
Assert.AreEqual(@"C:\", vm.RootLocations[1]);
Assert.AreEqual(@"E:\", vm.RootLocations[2]);
vm.SelectedIndex = 1;
vm.MovePathDownCommand.Execute(vm.SelectedIndex);
Assert.AreEqual(2, vm.SelectedIndex);
Assert.AreEqual(@"D:\", vm.RootLocations[0]);
Assert.AreEqual(@"E:\", vm.RootLocations[1]);
Assert.AreEqual(@"C:\", vm.RootLocations[2]);
}
public override void Setup()
{
base.Setup();
libraryCore = new ProtoCore.Core(new Options());
libraryCore.Compilers.Add(Language.Associative, new ProtoAssociative.Compiler(libraryCore));
libraryCore.Compilers.Add(Language.Imperative, new ProtoImperative.Compiler(libraryCore));
libraryCore.ParsingMode = ParseMode.AllowNonAssignment;
var pathResolver = new TestPathResolver();
pathResolver.AddPreloadLibraryPath("DSCoreNodes.dll");
var pathManager = new PathManager(new PathManagerParams
{
PathResolver = pathResolver
});
var settings = new PreferenceSettings();
libraryServices = new LibraryServices(libraryCore, pathManager, settings);
RegisterEvents();
}
public override void Setup()
{
base.Setup();
var settings = new PreferenceSettings();
var parentFolder = Path.Combine(TestDirectory, "pkgs", "multiple_locations");
settings.CustomPackageFolders = new List<string>
{
Path.Combine(parentFolder, "folder1"),
@"C:\folder_name_with_invalid_:*?|_characters\foobar",
@"C:\this_folder_doesn't_exist",
Path.Combine(parentFolder, "folder2"),
@"X:\this_drive_doesn't_exist",
@"\\unreachable_machine\share_packages",
Path.Combine(parentFolder, "folder3")
};
var settingFilePath = Path.Combine(TempFolder, "DynamoSettings.xml");
settings.Save(settingFilePath);
var settingsLoadedFromFile = PreferenceSettings.Load(settingFilePath);
StartDynamo(settingsLoadedFromFile);
}
protected DynamoModel(IStartConfiguration config)
{
ClipBoard = new ObservableCollection<ModelBase>();
pathManager = new PathManager(new PathManagerParams
{
CorePath = config.DynamoCorePath,
PathResolver = config.PathResolver
});
// Ensure we have all directories in place.
var exceptions = new List<Exception>();
pathManager.EnsureDirectoryExistence(exceptions);
Context = config.Context;
IsTestMode = config.StartInTestMode;
DebugSettings = new DebugSettings();
Logger = new DynamoLogger(DebugSettings, pathManager.LogDirectory);
foreach (var exception in exceptions)
{
Logger.Log(exception); // Log all exceptions.
}
MigrationManager = new MigrationManager(DisplayFutureFileMessage, DisplayObsoleteFileMessage);
MigrationManager.MessageLogged += LogMessage;
MigrationManager.MigrationTargets.Add(typeof(WorkspaceMigrations));
var thread = config.SchedulerThread ?? new DynamoSchedulerThread();
Scheduler = new DynamoScheduler(thread, IsTestMode ? TaskProcessMode.Synchronous : TaskProcessMode.Asynchronous);
Scheduler.TaskStateChanged += OnAsyncTaskStateChanged;
geometryFactoryPath = config.GeometryFactoryPath;
IPreferences preferences = CreateOrLoadPreferences(config.Preferences);
var settings = preferences as PreferenceSettings;
if (settings != null)
{
PreferenceSettings = settings;
PreferenceSettings.PropertyChanged += PreferenceSettings_PropertyChanged;
}
InitializePreferences(preferences);
InitializeInstrumentationLogger();
if (!isTestMode && this.PreferenceSettings.IsFirstRun)
{
DynamoMigratorBase migrator = null;
try
{
migrator = DynamoMigratorBase.MigrateBetweenDynamoVersions(pathManager, config.PathResolver);
}
catch (Exception e)
{
Logger.Log(e.Message);
}
if (migrator != null)
{
var isFirstRun = this.PreferenceSettings.IsFirstRun;
this.PreferenceSettings = migrator.PreferenceSettings;
// Preserve the preference settings for IsFirstRun as this needs to be set
// only by UsageReportingManager
this.PreferenceSettings.IsFirstRun = isFirstRun;
}
}
// At this point, pathManager.PackageDirectories only has 1 element which is the directory
// in AppData. If list of PackageFolders is empty, add the folder in AppData to the list since there
// is no additional location specified. Otherwise, update pathManager.PackageDirectories to include
// PackageFolders
if (PreferenceSettings.CustomPackageFolders.Count == 0)
PreferenceSettings.CustomPackageFolders = new List<string> {pathManager.UserDataDirectory};
else
pathManager.LoadCustomPackageFolders(PreferenceSettings.CustomPackageFolders);
SearchModel = new NodeSearchModel();
SearchModel.ItemProduced +=
node => ExecuteCommand(new CreateNodeCommand(node, 0, 0, true, true));
NodeFactory = new NodeFactory();
NodeFactory.MessageLogged += LogMessage;
CustomNodeManager = new CustomNodeManager(NodeFactory, MigrationManager);
InitializeCustomNodeManager();
extensionManager = new ExtensionManager();
extensionManager.MessageLogged += LogMessage;
var extensions = config.Extensions ?? ExtensionManager.ExtensionLoader.LoadDirectory(pathManager.ExtensionsDirectory);
Loader = new NodeModelAssemblyLoader();
Loader.MessageLogged += LogMessage;
// Create a core which is used for parsing code and loading libraries
var libraryCore =
new ProtoCore.Core(new Options { RootCustomPropertyFilterPathName = string.Empty });
libraryCore.Compilers.Add(Language.kAssociative, new Compiler(libraryCore));
libraryCore.Compilers.Add(Language.kImperative, new ProtoImperative.Compiler(libraryCore));
libraryCore.ParsingMode = ParseMode.AllowNonAssignment;
LibraryServices = new LibraryServices(libraryCore, pathManager);
LibraryServices.MessageLogged += LogMessage;
LibraryServices.LibraryLoaded += LibraryLoaded;
ResetEngineInternal();
AddHomeWorkspace();
AuthenticationManager = new AuthenticationManager(config.AuthProvider);
UpdateManager = config.UpdateManager ?? new DefaultUpdateManager(null);
UpdateManager.Log += UpdateManager_Log;
if (!IsTestMode)
{
DefaultUpdateManager.CheckForProductUpdate(UpdateManager);
}
Logger.Log(string.Format("Dynamo -- Build {0}",
Assembly.GetExecutingAssembly().GetName().Version));
InitializeNodeLibrary(preferences);
if (extensions.Any())
{
var startupParams = new StartupParams(config.AuthProvider,
pathManager, new ExtensionLibraryLoader(this), CustomNodeManager,
GetType().Assembly.GetName().Version, preferences);
foreach (var ext in extensions)
{
var logSource = ext as ILogSource;
if (logSource != null)
logSource.MessageLogged += LogMessage;
try
{
ext.Startup(startupParams);
}
catch (Exception ex)
{
Logger.Log(ex.Message);
}
ExtensionManager.Add(ext);
}
}
LogWarningMessageEvents.LogWarningMessage += LogWarningMessage;
StartBackupFilesTimer();
TraceReconciliationProcessor = this;
foreach (var ext in ExtensionManager.Extensions)
{
try
{
ext.Ready(new ReadyParams(this));
}
catch (Exception ex)
{
Logger.Log(ex.Message);
}
}
}
private PackagePathViewModel CreatePackagePathViewModel(PreferenceSettings setting)
{
PackageLoader loader = new PackageLoader(setting.CustomPackageFolders);
LoadPackageParams loadParams = new LoadPackageParams
{
Preferences = setting,
PathManager = Model.PathManager
};
CustomNodeManager customNodeManager = Model.CustomNodeManager;
return new PackagePathViewModel(loader, loadParams, customNodeManager);
}
public void PreferenceSetting()
{
// Test Case to ensure that the link for these persistent variable
// between DynamoViewModel, Controller is not broken or replaced.
#region FullscreenWatchShowing
bool expectedValue = !Controller.PreferenceSettings.FullscreenWatchShowing;
Vm.ToggleFullscreenWatchShowing(null);
Assert.AreEqual(expectedValue, Controller.PreferenceSettings.FullscreenWatchShowing);
expectedValue = !Controller.PreferenceSettings.FullscreenWatchShowing;
Vm.ToggleFullscreenWatchShowing(null);
Assert.AreEqual(expectedValue, Controller.PreferenceSettings.FullscreenWatchShowing);
#endregion
#region ShowConsole
expectedValue = !Controller.PreferenceSettings.ShowConsole;
Vm.ToggleConsoleShowing(null);
Assert.AreEqual(expectedValue, Controller.PreferenceSettings.ShowConsole);
expectedValue = !Controller.PreferenceSettings.ShowConsole;
Vm.ToggleConsoleShowing(null);
Assert.AreEqual(expectedValue, Controller.PreferenceSettings.ShowConsole);
#endregion
#region ConnectorType
ConnectorType expectedConnector = ConnectorType.BEZIER;
Vm.SetConnectorType("BEZIER");
Assert.AreEqual(expectedConnector, Controller.PreferenceSettings.ConnectorType);
expectedConnector = ConnectorType.POLYLINE;
Vm.SetConnectorType("POLYLINE");
Assert.AreEqual(expectedConnector, Controller.PreferenceSettings.ConnectorType);
Ui.Close();
#endregion
#region Save And Load of PreferenceSettings
// Test if variable can be serialize and deserialize without any issue
string tempPath = System.IO.Path.GetTempPath();
tempPath = Path.Combine(tempPath, "userPreference.xml");
// Force inital state
PreferenceSettings initalSetting = new PreferenceSettings();
PreferenceSettings resultSetting;
#region First Test
initalSetting.ConnectorType = ConnectorType.BEZIER;
initalSetting.ShowConsole = true;
initalSetting.FullscreenWatchShowing = true;
initalSetting.Save(tempPath);
resultSetting = PreferenceSettings.Load(tempPath);
Assert.AreEqual(resultSetting.FullscreenWatchShowing, initalSetting.FullscreenWatchShowing);
Assert.AreEqual(resultSetting.ConnectorType, initalSetting.ConnectorType);
Assert.AreEqual(resultSetting.ShowConsole, initalSetting.ShowConsole);
#endregion
#region Second Test
initalSetting.ConnectorType = ConnectorType.POLYLINE;
initalSetting.ShowConsole = false;
initalSetting.FullscreenWatchShowing = false;
initalSetting.Save(tempPath);
resultSetting = PreferenceSettings.Load(tempPath);
Assert.AreEqual(resultSetting.FullscreenWatchShowing, initalSetting.FullscreenWatchShowing);
Assert.AreEqual(resultSetting.ConnectorType, initalSetting.ConnectorType);
Assert.AreEqual(resultSetting.ShowConsole, initalSetting.ShowConsole);
#endregion
#endregion
}
private static void CreateMockPreferenceSettingsFile(string filePath, string packageDir)
{
var settings = new PreferenceSettings
{
CustomPackageFolders = new List<string>{packageDir}
};
settings.Save(filePath);
}
public void AddPackagePathsTest()
{
var setting = new PreferenceSettings()
{
CustomPackageFolders = { @"Z:\" }
};
var vm = CreatePackagePathViewModel(setting);
var path = string.Empty;
vm.RequestShowFileDialog += (sender, args) => { args.Path = path; };
var testDir = GetTestDirectory(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location));
path = Path.Combine(testDir, @"core\packagePathTest");
var dynFilePath = Path.Combine(path, @"dynFile\Number1.dyn");
vm.AddPathCommand.Execute(null);
vm.SaveSettingCommand.Execute(null);
Model.ExecuteCommand(new DynamoModel.OpenFileCommand(dynFilePath));
Assert.AreEqual(1,GetPreviewValue("07d62dd8-b2f3-40a8-a761-013d93300444"));
}
