public void ConfigurationRedirection()
{
//Inject test config to UpdateManager instance, using reflection.
var config = new UpdateManagerConfiguration()
{
DownloadSourcePath = DOWNLOAD_SOURCE_PATH_S,
SignatureSourcePath = SIGNATURE_SOURCE_PATH_S
};
var um = new DynUpdateManager(config);
Assert.IsNotNull(um);
var updateRequest = new Mock <IAsynchronousRequest>();
updateRequest.Setup(ur => ur.Data)
.Returns(UpdateManagerTestHelpers.updateAvailableData);
um.UpdateDataAvailable(updateRequest.Object);
// Spoof a download completion by setting the downloaded update info to the update info
um.DownloadedUpdateInfo = um.UpdateInfo;
Assert.NotNull(um.UpdateInfo);
Assert.AreEqual("9.9.9.0", um.AvailableVersion.ToString());
Assert.AreEqual(DOWNLOAD_SOURCE_PATH_S, um.UpdateInfo.VersionInfoURL);
Assert.AreEqual(
SIGNATURE_SOURCE_PATH_S + @"DynamoInstall9.9.9.sig",
um.UpdateInfo.SignatureURL);
}
public void UpdateManagerConfigurationLoadTest()
{
Assert.IsNull(UpdateManagerConfiguration.Load(null, updateManager));
Assert.IsNull(UpdateManagerConfiguration.Load("", updateManager));
Assert.IsNull(UpdateManagerConfiguration.Load("filePath", updateManager));
Assert.IsNull(UpdateManagerConfiguration.Load(Path.GetTempFileName(), updateManager));
}
public void ConfigurationSerialization()
{
var config = new UpdateManagerConfiguration()
{
DownloadSourcePath = DOWNLOAD_SOURCE_PATH_S,
SignatureSourcePath = SIGNATURE_SOURCE_PATH_S
};
//save to a temp file.
var tempFile = Path.GetTempFileName();
Assert.DoesNotThrow(() => config.Save(tempFile, null));
//read from a temp file.
UpdateManagerConfiguration savedConfig = null;
Assert.DoesNotThrow(() => savedConfig = UpdateManagerConfiguration.Load(tempFile, null));
//Compare parameters.
Assert.IsNotNull(savedConfig);
Assert.AreEqual(config.CheckNewerDailyBuild, savedConfig.CheckNewerDailyBuild);
Assert.AreEqual(config.SignatureSourcePath, savedConfig.SignatureSourcePath);
Assert.AreEqual(config.DownloadSourcePath, savedConfig.DownloadSourcePath);
Assert.AreEqual(config.ForceUpdate, savedConfig.ForceUpdate);
Assert.AreEqual(config.DisableUpdates, savedConfig.DisableUpdates);
}
public void Init()
{
//Create an instance of the UpdateManager class to be used in the tests.
var config = UpdateManagerConfiguration.GetSettings(null);
updateManager = new UpdateManager(config);
}
private static RevitDynamoModel InitializeCoreModel(DynamoRevitCommandData commandData)
{
var assemblyLocation = Assembly.GetExecutingAssembly().Location;
var assemblyDirectory = Path.GetDirectoryName(assemblyLocation);
var parentDirectory = Directory.GetParent(assemblyDirectory);
var corePath = parentDirectory.FullName;
var umConfig = UpdateManagerConfiguration.GetSettings(new DynamoRevitLookUp());
Debug.Assert(umConfig.DynamoLookUp != null);
return(RevitDynamoModel.Start(
new RevitDynamoModel.RevitStartConfiguration()
{
GeometryFactoryPath = GetGeometryFactoryPath(corePath),
PathResolver = new RevitPathResolver(),
Context = GetRevitContext(commandData),
SchedulerThread = new RevitSchedulerThread(commandData.Application),
StartInTestMode = isAutomationMode,
AuthProvider = new RevitOxygenProvider(new DispatcherSynchronizationContext(Dispatcher.CurrentDispatcher)),
ExternalCommandData = commandData,
UpdateManager = new DynUpdateManager(umConfig),
ProcessMode = isAutomationMode ? TaskProcessMode.Synchronous : TaskProcessMode.Asynchronous
}));
}
private static RevitDynamoModel InitializeCoreModel(DynamoRevitCommandData commandData)
{
var corePath = DynamoRevitApp.DynamoCorePath;
var dynamoRevitExePath = Assembly.GetExecutingAssembly().Location;
var dynamoRevitRoot = Path.GetDirectoryName(dynamoRevitExePath);// ...\Revit_xxxx\ folder
var umConfig = UpdateManagerConfiguration.GetSettings(new DynamoRevitLookUp());
Debug.Assert(umConfig.DynamoLookUp != null);
var userDataFolder = Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
"Dynamo", "Dynamo Revit");
var commonDataFolder = Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData),
"Dynamo", "Dynamo Revit");
return(RevitDynamoModel.Start(
new RevitDynamoModel.RevitStartConfiguration()
{
DynamoCorePath = corePath,
DynamoHostPath = dynamoRevitRoot,
GeometryFactoryPath = GetGeometryFactoryPath(corePath),
PathResolver = new RevitPathResolver(userDataFolder, commonDataFolder),
Context = GetRevitContext(commandData),
SchedulerThread = new RevitSchedulerThread(commandData.Application),
StartInTestMode = isAutomationMode,
AuthProvider = new RevitOxygenProvider(new DispatcherSynchronizationContext(Dispatcher.CurrentDispatcher)),
ExternalCommandData = commandData,
UpdateManager = new DynUpdateManager(umConfig),
ProcessMode = isAutomationMode ? TaskProcessMode.Synchronous : TaskProcessMode.Asynchronous
}));
}
/// <summary>
///if we are building a model for CLI mode, then we don't want to start an updateManager
///for now, building an updatemanager instance requires finding Dynamo install location
///which if we are running on mac os or *nix will use different logic then SandboxLookup
/// </summary>
private static IUpdateManager InitializeUpdateManager()
{
var cfg = UpdateManagerConfiguration.GetSettings(new SandboxLookUp());
var um = new Dynamo.Updates.UpdateManager(cfg);
Debug.Assert(cfg.DynamoLookUp != null);
return(um);
}
public void UpdateManagerConfigurationLoadTest()
{
//Testing all the calls for Load that return null
Assert.IsNull(UpdateManagerConfiguration.Load(null, updateManager));
Assert.IsNull(UpdateManagerConfiguration.Load("", updateManager));
Assert.IsNull(UpdateManagerConfiguration.Load("filePath", updateManager));
Assert.IsNull(UpdateManagerConfiguration.Load(Path.GetTempFileName(), updateManager));
}
private readonly FieldInfo fieldInfo; //internal configuration field.
/// <summary>
/// Creates ConfigInjection instance.
/// </summary>
/// <param name="updateManager">UpdateManager instance to which configuration is to be injected.</param>
/// <param name="configuration">The configuration for injection.</param>
public ConfigInjection(DynUpdateManager updateManager, UpdateManagerConfiguration configuration)
{
this.updateManager = updateManager;
fieldInfo = updateManager.GetType()
.GetField("configuration", BindingFlags.NonPublic | BindingFlags.Instance);
Assert.IsNotNull(fieldInfo);
this.configuration = fieldInfo.GetValue(updateManager);
fieldInfo.SetValue(updateManager, configuration);
}
private static RevitDynamoModel InitializeCoreModel(DynamoRevitCommandData commandData)
{
// Temporary fix to pre-load DLLs that were also referenced in Revit folder.
// To do: Need to align with Revit when provided a chance.
PreloadDynamoCoreDlls();
var corePath = DynamoRevitApp.DynamoCorePath;
var dynamoRevitExePath = Assembly.GetExecutingAssembly().Location;
var dynamoRevitRoot = Path.GetDirectoryName(dynamoRevitExePath);// ...\Revit_xxxx\ folder
// get Dynamo Revit Version
var dynRevitVersion = Assembly.GetExecutingAssembly().GetName().Version;
var umConfig = UpdateManagerConfiguration.GetSettings(new DynamoRevitLookUp());
var revitUpdateManager = new DynUpdateManager(umConfig);
revitUpdateManager.HostVersion = dynRevitVersion; // update RevitUpdateManager with the current DynamoRevit Version
revitUpdateManager.HostName = "Dynamo Revit";
if (revitUpdateManager.Configuration is IDisableUpdateConfig)
{
(revitUpdateManager.Configuration as IDisableUpdateConfig).DisableUpdates = true;
}
Debug.Assert(umConfig.DynamoLookUp != null);
var userDataFolder = Path.Combine(Environment.GetFolderPath(
Environment.SpecialFolder.ApplicationData),
"Dynamo", "Dynamo Revit");
var commonDataFolder = Path.Combine(Environment.GetFolderPath(
Environment.SpecialFolder.CommonApplicationData),
"Autodesk", "RVT " + commandData.Application.Application.VersionNumber, "Dynamo");
bool isAutomationMode = CheckJournalForKey(extCommandData, JournalKeys.AutomationModeKey);
// when Dynamo runs on top of Revit we must load the same version of ASM as revit
// so tell Dynamo core we've loaded that version.
var loadedLibGVersion = PreloadAsmFromRevit();
return(RevitDynamoModel.Start(
new RevitDynamoModel.RevitStartConfiguration()
{
DynamoCorePath = corePath,
DynamoHostPath = dynamoRevitRoot,
GeometryFactoryPath = GetGeometryFactoryPath(corePath, loadedLibGVersion),
PathResolver = new RevitPathResolver(userDataFolder, commonDataFolder),
Context = GetRevitContext(commandData),
SchedulerThread = new RevitSchedulerThread(commandData.Application),
StartInTestMode = isAutomationMode,
AuthProvider = new RevitOxygenProvider(new DispatcherSynchronizationContext(Dispatcher.CurrentDispatcher)),
ExternalCommandData = commandData,
UpdateManager = revitUpdateManager,
ProcessMode = isAutomationMode ? TaskProcessMode.Synchronous : TaskProcessMode.Asynchronous
}));
}
public void UpdateManagerConfigurationPropertiesTest()
{
var config = new UpdateManagerConfiguration();
var checkNewerDailyBuildOldValue = config.CheckNewerDailyBuild;
config.CheckNewerDailyBuild = !config.CheckNewerDailyBuild;
Assert.AreEqual(!checkNewerDailyBuildOldValue, config.CheckNewerDailyBuild);
var forceUpdateOldValue = config.ForceUpdate;
config.ForceUpdate = !config.ForceUpdate;
Assert.AreEqual(!forceUpdateOldValue, config.ForceUpdate);
}
public void UpdateManagerConfigurationSaveTest()
{
var config = new UpdateManagerConfiguration();
var goodPath = Path.GetTempFileName();
var badPath = "W:\\PathThatDoesntExist";
//Happy path
Assert.DoesNotThrow(() => config.Save(goodPath, updateManager));
//if statement in the catch block
Assert.DoesNotThrow(() => config.Save(badPath, updateManager));
//else statement in the catch block
Assert.Throws <DirectoryNotFoundException>(() => config.Save(badPath, null));
}
private static Mock <IUpdateManager> MockUpdateManager(string availableVersion, string productVersion)
{
var um_mock = new Mock <IUpdateManager>();
um_mock.Setup(um => um.AvailableVersion).Returns(BinaryVersion.FromString(availableVersion));
um_mock.Setup(um => um.ProductVersion).Returns(BinaryVersion.FromString(productVersion));
var config = new UpdateManagerConfiguration()
{
DownloadSourcePath = DOWNLOAD_SOURCE_PATH_S,
SignatureSourcePath = SIGNATURE_SOURCE_PATH_S
};
um_mock.Setup(um => um.Configuration).Returns(config);
var fieldInfo = typeof(UpdateManager).GetField("instance", BindingFlags.Static | BindingFlags.NonPublic);
Assert.NotNull(fieldInfo);
fieldInfo.SetValue(UpdateManager.Instance, um_mock.Object);
return(um_mock);
}
private static void MakeStandaloneAndRun(string commandFilePath, out DynamoViewModel viewModel)
{
var geometryFactoryPath = string.Empty;
var preloaderLocation = string.Empty;
PreloadShapeManager(ref geometryFactoryPath, ref preloaderLocation);
DynamoModel.RequestMigrationStatusDialog += MigrationStatusDialogRequested;
var umConfig = UpdateManagerConfiguration.GetSettings(new SandboxLookUp());
Debug.Assert(umConfig.DynamoLookUp != null);
var model = DynamoModel.Start(
new DynamoModel.DefaultStartConfiguration()
{
PathResolver = new PathResolver(preloaderLocation),
GeometryFactoryPath = geometryFactoryPath,
UpdateManager = new UpdateManager(umConfig)
});
viewModel = DynamoViewModel.Start(
new DynamoViewModel.StartConfiguration()
{
CommandFilePath = commandFilePath,
DynamoModel = model
});
var view = new DynamoView(viewModel);
view.Loaded += (sender, args) => CloseMigrationWindow();
var app = new Application();
app.Run(view);
DynamoModel.RequestMigrationStatusDialog -= MigrationStatusDialogRequested;
}
public void UpdateManagerConfigurationSaveTest()
{
var config = new UpdateManagerConfiguration();
Assert.DoesNotThrow(() => config.Save(Path.GetTempFileName(), updateManager));
}
public void Init()
{
var config = UpdateManagerConfiguration.GetSettings(null);
updateManager = new UpdateManager(config);
}
