public void findDependencies_HardcodedDependencyNotInstalled()
{
var inst = new Installation(Directory.GetCurrentDirectory());
var pkgs = inst.GetPackages();
string inputXml = @"<?xml version='1.0' encoding='utf-8' ?>
<Package Name='Test3' xmlns ='http://opentap.io/schemas/package'>
<Dependencies>
<PackageDependency Package='NotInstalled' Version='Any'/>
</Dependencies>
<Files>
<File Path='OpenTap.Package.UnitTests.dll'/>
</Files>
</Package>
";
string inputFilename = "test3.package.xml";
File.WriteAllText(inputFilename, inputXml);
try
{
PackageDef pkg = PackageDefExt.FromInputXml(inputFilename, Directory.GetCurrentDirectory());
Assert.Fail("Missing dependency should have thrown an exception");
}
catch (Cli.ExitCodeException ex)
{
Assert.AreEqual((int)PackageCreateAction.ExitCodes.PackageDependencyError, ex.ExitCode);
}
}
/// <summary>
/// Load the input as a PackageDef, saves it again and compares the saved output to the original input
/// </summary>
/// <param name="input"></param>
private static void LoadSaveCompare(string input, string expectedOutput)
{
PackageDef pkg;
byte[] inputArray = System.Text.Encoding.ASCII.GetBytes(input);
using (MemoryStream inputStream = new MemoryStream(inputArray))
{
pkg = PackageDef.FromXml(inputStream);
}
string output = "";
using (Stream str = new MemoryStream())
{
pkg.SaveTo(str);
using (StreamReader reader = new StreamReader(str))
{
reader.BaseStream.Seek(0, 0);
output = reader.ReadToEnd();
}
}
XDocument inputDoc = XDocument.Parse(expectedOutput);
XDocument outputDoc = XDocument.Parse(output);
AssertElementEquals(inputDoc.Root, outputDoc.Root);
AssertElementEquals(outputDoc.Root, inputDoc.Root);
}
internal static void RunCustomActions(PackageDef package, PackageActionStage stage, CustomPackageActionArgs args)
{
var customActions = PluginManager.GetPlugins <ICustomPackageAction>()
.Select(s => Activator.CreateInstance(s) as ICustomPackageAction)
.Where(w => w.ActionStage == stage)
.OrderBy(p => p.Order())
.ToList();
if (customActions.Count == 0)
{
log.Debug($"Found no custom actions to run at '{stage.ToString().ToLower()}' stage.");
return;
}
log.Debug($"Available custom actions for '{stage.ToString().ToLower()}' stage. ({customActions.Count} actions: {string.Join(", ", customActions.Select(s => s.ToString()))})");
foreach (ICustomPackageAction action in customActions)
{
Stopwatch timer = Stopwatch.StartNew();
try
{
if (action.Execute(package, args))
{
log.Info(timer, $"Package action {action.GetType().Name} completed");
continue;
}
}
catch (Exception ex)
{
log.Warning(timer, $"Package action {action.ToString()} failed", ex);
throw;
}
}
}
public void NoDowngradeInstallTest()
{
var installation = new Installation(Directory.GetCurrentDirectory());
var package = new PackageDef();
package.Name = "NoDowngradeTest";
package.Version = SemanticVersion.Parse("1.0.1");
var newPath = DummyPackageGenerator.GeneratePackage(package);
package.Version = SemanticVersion.Parse("1.0.0");
var oldPath = DummyPackageGenerator.GeneratePackage(package);
// Install new version
var output = RunPackageCli($"install {newPath}", out int exitCode);
Assert.IsTrue(exitCode == 0 && output.ToLower().Contains("installed"), "NoDowngradeTest package was not installed.");
var installedVersion = installation.GetPackages()?.FirstOrDefault(p => p.Name == "NoDowngradeTest")?.Version;
Assert.IsTrue(installedVersion == SemanticVersion.Parse("1.0.1"), $"NoDowngradeTest installed the wrong version: '{installedVersion}'.");
// Install older version with --no-downgrade option. This should not install the old version.
output = RunPackageCli($"install --no-downgrade {oldPath}", out exitCode);
Assert.IsTrue(exitCode == 0 && output.ToLower().Contains("already installed"), "NoDowngradeTest package was not installed.");
installedVersion = installation.GetPackages()?.FirstOrDefault(p => p.Name == "NoDowngradeTest")?.Version;
Assert.IsTrue(installedVersion == SemanticVersion.Parse("1.0.1"), $"NoDowngradeTest failed to skip the install: '{installedVersion}'.");
// Install older version without --no-downgrade option. This should install the old version.
output = RunPackageCli($"install {oldPath}", out exitCode);
Assert.IsTrue(exitCode == 0 && output.ToLower().Contains("installed"), "NoDowngradeTest package was not installed.");
installedVersion = installation.GetPackages()?.FirstOrDefault(p => p.Name == "NoDowngradeTest")?.Version;
Assert.IsTrue(installedVersion == SemanticVersion.Parse("1.0.0"), $"NoDowngradeTest failed to install the old version: '{installedVersion}'.");
}
public void InstallFileWithMissingDependencyTest()
{
var def = new PackageDef();
def.Name = "Dummy2";
def.OS = "Windows,Linux";
def.Version = SemanticVersion.Parse("1.0");
def.AddFile("Dummy.txt");
def.Dependencies.Add(new PackageDependency("Missing", VersionSpecifier.Parse("1.0")));
DummyPackageGenerator.InstallDummyPackage("Missing");
string pkgFile = DummyPackageGenerator.GeneratePackage(def);
DummyPackageGenerator.UninstallDummyPackage("Missing");
try
{
int exitCode;
string output = RunPackageCli("install Dummy2 -y", out exitCode);
//Assert.AreNotEqual(0, exitCode, "Unexpected exit code");
StringAssert.Contains("'Missing' with a version compatible with 1.0", output);
}
finally
{
File.Delete(pkgFile);
}
}
static void tryUninstall(string path, PackageDef package, string target)
{
log.Info("Uninstalling package '{0}'.", package.Name);
Uninstall(package, target);
log.Flush();
log.Info("Uninstalled package '{0}'.", path);
}
/// <summary>
/// Loads and manages Index2, Catalog2, PackageDef objects
/// </summary>
/// <param name="workingDirectory"></param>
public SongManager(string workingDirectory)
{
// Returns if directory doesn't exist
if (!Directory.Exists(workingDirectory))
{
return;
}
_workingDirectory = workingDirectory;
string[] rifFiles = Directory.GetFiles(_workingDirectory, "*.rif", SearchOption.TopDirectoryOnly);
// Loads objects from riff files
foreach (string rifFile in rifFiles)
{
RiffFile rif = new RiffFile();
rif.Import(rifFile);
foreach (ZObject zobj in rif.Objects)
{
if (zobj is Index2)
{
_index2 = zobj as Index2;
LoadStringTablePaths();
}
else if (zobj is Catalog2)
{
_catalog2 = zobj as Catalog2;
}
else if (zobj is PackageDef)
{
_packageDef = zobj as PackageDef;
}
}
}
// Look for PackageDef
string[] packageDefs = Directory.GetFiles(Path.Combine(_workingDirectory, "packagedefs"), "packagedef.rif", SearchOption.AllDirectories);
//packageDefs = packageDefs.OrderBy(x => x).ToArray();
if (packageDefs.Length <= 0)
{
return;
}
RiffFile packageDef = new RiffFile();
packageDef.Import(packageDefs[0]);
foreach (ZObject zobj in packageDef.Objects)
{
if (zobj is PackageDef)
{
_packageDef = zobj as PackageDef;
break;
}
}
UpdateStringTableFromHKey(_index2.IndexKey);
UpdateStringTableFromHKey(_catalog2.IndexKey);
UpdateStringTableFromHKey(_packageDef.IndexKey);
}
public void InstallLocalFile()
{
var package = new PackageDef();
package.Name = "Dummy Something";
package.Version = SemanticVersion.Parse("1.0.0");
package.Description = "Cached version";
var file = DummyPackageGenerator.GeneratePackage(package);
if (File.Exists(Path.Combine("PackageCache", file)))
{
File.Delete(Path.Combine("PackageCache", file));
}
File.Move(file, Path.Combine("PackageCache", file));
package.Description = "Right version";
var file2 = DummyPackageGenerator.GeneratePackage(package);
var result = RunPackageCli("install -v -f \"" + Path.GetFullPath(file2) + "\"", out int exitcode);
Assert.IsTrue(result.ToLower().Contains("installed"));
Assert.IsTrue(result.ToLower().Contains("downloading file without searching"));
var installedPackage = new Installation(Directory.GetCurrentDirectory()).GetPackages().FirstOrDefault(p => p.Name == package.Name);
Assert.IsNotNull(installedPackage, "Package was not installed");
Assert.AreEqual(package.Description, installedPackage.Description);
}
/// <summary>
/// Returns the names of the files in a plugin package.
/// </summary>
/// <param name="packagePath"></param>
/// <returns></returns>
internal static List <string> FilesInPackage(string packagePath)
{
List <string> files = new List <string>();
string fileType = Path.GetExtension(packagePath);
if (fileType == ".xml")
{
var pkg = PackageDef.FromXml(packagePath);
return(pkg.Files.Select(f => f.FileName).ToList());
}
try
{
using (var fileStream = File.OpenRead(packagePath))
using (var zip = new ZipArchive(fileStream, ZipArchiveMode.Read))
{
foreach (var part in zip.Entries)
{
if (part.Name == "[Content_Types].xml" || part.Name == ".rels" || part.FullName.StartsWith("package/services/metadata/core-properties"))
{
continue; // skip strange extra files that are created by System.IO.Packaging.Package (TAP 7.x)
}
string path = Uri.UnescapeDataString(part.FullName);
files.Add(path);
}
}
}
catch (InvalidDataException)
{
log.Error($"Could not unpackage '{packagePath}'.");
throw;
}
return(files);
}
IEnumerable<string> GetUrls(PackageDef packageDef)
{
foreach (var feed in PackageFeeds)
{
if (IsLocalPath(feed))
{
// Local
yield return Path.Combine(feed, string.Format("{0}.{1}.nupkg", packageDef.Id, packageDef.Version));
}
else
{
// Online
var nugetUrl = feed;
nugetUrl = nugetUrl.TrimEnd('/');
if (!nugetUrl.EndsWith("package",StringComparison.OrdinalIgnoreCase))
{
nugetUrl += "/package";
}
yield return string.Format("{0}/{1}/{2}", nugetUrl, packageDef.Id, packageDef.Version);
}
}
//return AdditionalFeeds
// .Select(source => string.Format("{0}/api/v2/package/{1}/{2}", source, packageDef.Id, packageDef.Version));
}
/// <summary>
/// Compresses the files to a zip package.
/// </summary>
static private void Compress(this PackageDef pkg, string outputPath, IEnumerable <PackageFile> inputPaths)
{
var dir = Path.GetDirectoryName(outputPath);
if (String.IsNullOrWhiteSpace(dir) == false)
{
Directory.CreateDirectory(dir);
}
using (var zip = new System.IO.Compression.ZipArchive(File.Open(outputPath, FileMode.Create), System.IO.Compression.ZipArchiveMode.Create))
{
foreach (PackageFile file in inputPaths)
{
var sw = Stopwatch.StartNew();
var relFileName = file.RelativeDestinationPath;
var ZipPart = zip.CreateEntry(relFileName, System.IO.Compression.CompressionLevel.Optimal);
using (var instream = File.OpenRead(file.FileName))
{
using (var outstream = ZipPart.Open())
{
var compressTask = instream.CopyToAsync(outstream, 2048, TapThread.Current.AbortToken);
ConsoleUtils.PrintProgressTillEnd(compressTask, "Compressing", () => instream.Position, () => instream.Length);
}
}
log.Debug(sw, "Compressed '{0}'", file.FileName);
}
// add the metadata xml file:
var metaPart = zip.CreateEntry(String.Join("/", PackageDef.PackageDefDirectory, pkg.Name, PackageDef.PackageDefFileName), System.IO.Compression.CompressionLevel.Optimal);
using (var str = metaPart.Open())
pkg.SaveTo(str);
}
}
public static List <PackageDef> GetInstallation()
{
var opentap = new PackageDef
{
Name = "OpenTAP",
RawVersion = "1.0.0"
};
var A = new PackageDef()
{
Name = "A",
RawVersion = "1.0.0"
};
A.Dependencies.Add(new PackageDependency("OpenTAP", VersionSpecifier.Any));
var file = new PackageFile();
file.FileName = "Package/A/test";
file.CustomData.Add(new FileHashPackageAction.Hash {
Value = "TEST1234"
});
A.Files.Add(file);
var file2 = new PackageFile();
file2.FileName = "Dependencies/A/test";
file2.CustomData.Add(new FileHashPackageAction.Hash {
Value = "TEST1234"
});
A.Files.Add(file2);
return(new List <PackageDef> {
opentap, A
});
}
public void DependencyAnalyzerBuildAnalyzerContextTest()
{
log.Info("-----------------------------DependencyAnalyzer BuildAnalyzerContext-----------------------------");
// Test setup.
var tapPackage = new PackageDef()
{
Name = "Tap", Version = PluginManager.GetOpenTapAssembly().SemanticVersion
};
var packages = new List <PackageDef>();
packages.Add(tapPackage);
// Correct packages.
using (var xmlText = File.OpenRead(Path.Combine(Directory.GetCurrentDirectory(), "TapPackages/MyPlugin1.xml")))
{
packages.AddRange(PackageDef.ManyFromXml(xmlText));
// Multiple identical packages.
xmlText.Seek(0, 0);
packages.AddRange(PackageDef.ManyFromXml(xmlText));
}
// Reset test.
packages.Clear();
// No packages.
var dependencyAnalyzer = DependencyAnalyzer.BuildAnalyzerContext(packages);
Assert.IsTrue(dependencyAnalyzer.BrokenPackages.Count == 0, "No packages");
log.Info("Multiple identical items - SUCCESS");
}
public static List <PackageDef> TestNonConflicting()
{
var B = new PackageDef {
Name = "B", RawVersion = "2.0.0"
};
var file = new PackageFile {
FileName = "Package/A/test"
};
file.CustomData.Add(new FileHashPackageAction.Hash {
Value = "TEST1234"
}); // same hash
B.Files.Add(file);
var C = new PackageDef {
Name = "C", RawVersion = "2.0.0"
};
var file2 = new PackageFile {
FileName = "Package/B/test"
};
file2.CustomData.Add(new FileHashPackageAction.Hash {
Value = "TEST1234"
});
B.Files.Add(file2);
return(new List <PackageDef> {
B, C
});
}
/// <summary>
/// Returns package definition list of installed packages in the TAP installation defined in the constructor, and system-wide packages.
/// </summary>
/// <returns></returns>
public List <PackageDef> GetPackages()
{
List <PackageDef> plugins = new List <PackageDef>();
List <string> package_files = new List <string>();
// Add normal package from OpenTAP folder
package_files.AddRange(PackageDef.GetPackageMetadataFilesInTapInstallation(TapPath));
// Add system wide packages
package_files.AddRange(PackageDef.GetSystemWidePackages());
foreach (var file in package_files)
{
var package = installedPackageMemorizer.Invoke(file);
if (package != null && !plugins.Any(s => s.Name == package.Name))
{
#pragma warning disable 618
package.Location = file;
#pragma warning restore 618
package.PackageSource = new InstalledPackageDefSource
{
Installation = this,
PackageDefFilePath = file
};
plugins.Add(package);
}
}
return(plugins);
}
public void InstalledPackages_InvalidXmlIgnored()
{
Assert.IsTrue(File.Exists(PackageDef.GetDefaultPackageMetadataPath("XSeries")), "Necessary package file missing.");
File.WriteAllText(Path.Combine(PackageDef.PackageDefDirectory, "Invalid.package.xml"),
@"<?xml version='1.0' encoding='utf-8' ?>
<Package Name='Invalid' xmlns='http://keysight.com/schemas/TAP/Package'>
<Files>
<File Path='Tap.Engine.dll' Obfuscate='false'><UseVersion/></File>
</Files>
<FileName>This should not be there<FileName/>
</Package>");
System.Collections.Generic.List <PackageDef> target = new Installation(Directory.GetCurrentDirectory()).GetPackages();;
CollectionAssert.AllItemsAreInstancesOfType(target, typeof(PackageDef));
CollectionAssert.AllItemsAreNotNull(target);
CollectionAssert.AllItemsAreUnique(target);
Assert.IsTrue(target.Any(pkg => pkg.Name == "XSeries"));
Assert.IsTrue(target.Any(pkg => pkg.Name == "Test"));
Assert.IsFalse(target.Any(pkg => pkg.Name == "Invalid"));
File.Delete(Path.Combine(PackageDef.PackageDefDirectory, "Invalid.package.xml"));
}
public void UninstallFirstTest()
{
var dep0Def = new PackageDef();
dep0Def.Name = "UninstallPackage";
dep0Def.Version = SemanticVersion.Parse("0.1");
dep0Def.AddFile("UninstallText.txt");
string dep0File = DummyPackageGenerator.GeneratePackage(dep0Def);
var dep1Def = new PackageDef();
dep1Def.Name = "UninstallPackage";
dep1Def.Version = SemanticVersion.Parse("0.2");
dep1Def.AddFile("SubDir/UninstallText.txt");
Directory.CreateDirectory("SubDir");
string dep1File = DummyPackageGenerator.GeneratePackage(dep1Def);
int exitCode;
string output = RunPackageCli("install " + dep0File, out exitCode);
Assert.AreEqual(0, exitCode, "Unexpected exit code1: " + output);
Assert.IsTrue(File.Exists("UninstallText.txt"), "File0 should exist");
output = RunPackageCli("install " + dep1File, out exitCode);
Assert.AreEqual(0, exitCode, "Unexpected exit code2: " + output);
Assert.IsTrue(File.Exists("SubDir/UninstallText.txt"), "File1 should exist");
Assert.IsFalse(File.Exists("UninstallText.txt"), "File0 should not exist");
}
private void GetDependenciesRecursive(List <IPackageRepository> repositories, PackageDependency dependency, CpuArchitecture packageArchitecture, string OS)
{
if (Dependencies.Any(p => (p.Name == dependency.Name) &&
dependency.Version.IsCompatible(p.Version) &&
ArchitectureHelper.PluginsCompatible(p.Architecture, packageArchitecture)))
{
return;
}
PackageDef depPkg = GetPackageDefFromInstallation(dependency.Name, dependency.Version);
if (depPkg == null)
{
depPkg = GetPackageDefFromRepo(repositories, dependency.Name, dependency.Version);
MissingDependencies.Add(depPkg);
}
if (depPkg == null)
{
UnknownDependencies.Add(dependency);
return;
}
Dependencies.Add(depPkg);
foreach (var nextLevelDep in depPkg.Dependencies)
{
GetDependenciesRecursive(repositories, nextLevelDep, packageArchitecture, OS);
}
}
private static void AddFileDependencies(PackageDef pkg, AssemblyData dependency, AssemblyData foundAsm)
{
var depender = pkg.Files.FirstOrDefault(f => f.DependentAssemblies.Contains(dependency));
if (depender == null)
{
log.Warning("Adding dependent assembly '{0}' to package. It was not found in any other packages.", Path.GetFileName(foundAsm.Location));
}
else
{
log.Info($"'{Path.GetFileName(depender.FileName)}' dependents on '{dependency.Name}' version '{dependency.Version}'. Adding dependency to package, it was not found in any other packages.");
}
var destPath = string.Format("Dependencies/{0}.{1}/{2}", Path.GetFileNameWithoutExtension(foundAsm.Location), foundAsm.Version.ToString(), Path.GetFileName(foundAsm.Location));
pkg.Files.Add(new PackageFile {
SourcePath = foundAsm.Location, RelativeDestinationPath = destPath, DependentAssemblies = foundAsm.References.ToList()
});
// Copy the file to the actual directory so we can rely on it actually existing where we say the package has it.
if (!File.Exists(destPath))
{
Directory.CreateDirectory(Path.GetDirectoryName(destPath));
ProgramHelper.FileCopy(foundAsm.Location, destPath);
}
}
public void SkipInstallExactVersionAlreadyInstalledTest()
{
var package = new PackageDef();
package.Name = "ExactVersionTest";
package.Version = SemanticVersion.Parse("1.0.1");
package.OS = "Windows,Linux";
var path = DummyPackageGenerator.GeneratePackage(package);
// Install
var output = RunPackageCli($"install {path}", out int exitCode);
Assert.IsTrue(exitCode == 0 && output.ToLower().Contains("installed"), "ExactVersionTest package was not installed.");
// Install the exact same version. This should skip.
output = RunPackageCli($"install {package.Name} --version 1.0.1", out exitCode);
Assert.IsTrue(exitCode == 0 && output.ToLower().Contains("already installed"), "ExactVersionTest package install was not skipped.");
// Install the exact same version with --force. This should not skip.
output = RunPackageCli($"install {package.Name} --version 1.0.1 -f", out exitCode);
Assert.IsTrue(exitCode == 0 && output.ToLower().Contains("already installed") == false, "ExactVersionTest package install with -f was skipped.");
// Install the exact same version from file. This should not skip.
output = RunPackageCli($"install {path}", out exitCode);
Assert.IsTrue(exitCode == 0 && output.ToLower().Contains("already installed") == false, "ExactVersionTest package install was skipped.");
}
public static string GeneratePackage(PackageDef definition)
{
foreach (var packageFile in definition.Files)
{
File.CreateText(packageFile.FileName).Close();
}
string defFileName = "generated_package.xml";
using (var stream = File.Create(defFileName))
definition.SaveTo(stream);
var proc = OpenTap.Engine.UnitTests.TapProcessContainer.StartFromArgs("package create " + defFileName, TimeSpan.FromMinutes(5));
proc.WaitForEnd();
string output = proc.ConsoleOutput;
string outputFile = definition.Name + "." + definition.Version + ".TapPackage";
if (File.Exists(outputFile))
{
return(outputFile);
}
else
{
throw new Exception(output);
}
}
private static void updateVersion(this PackageDef pkg, string ProjectDirectory)
{
// Replace macro if possible
pkg.RawVersion = TryReplaceMacro(pkg.RawVersion, ProjectDirectory);
foreach (var depPackage in pkg.Dependencies)
{
ReplaceDependencyVersion(ProjectDirectory, depPackage);
}
if (pkg.RawVersion == null)
{
foreach (var file in pkg.Files.Where(file => file.HasCustomData <UseVersionData>()))
{
pkg.Version = PluginManager.GetSearcher().Assemblies.FirstOrDefault(a => Path.GetFullPath(a.Location) == Path.GetFullPath(file.FileName)).SemanticVersion;
break;
}
}
else
{
if (String.IsNullOrWhiteSpace(pkg.RawVersion))
{
pkg.Version = new SemanticVersion(0, 0, 0, null, null);
}
else if (SemanticVersion.TryParse(pkg.RawVersion, out var semver))
{
pkg.Version = semver;
}
else
{
throw new FormatException("The version string in the package is not a valid semantic version.");
}
}
}
public void GetPluginName_Test()
{
string inputFilename = "Packages/test2/package.xml";
PackageDef pkg = PackageDefExt.FromInputXml(inputFilename, Directory.GetCurrentDirectory());
Assert.AreEqual("Test Step", pkg.Files?.FirstOrDefault()?.Plugins?.FirstOrDefault(p => p.Type == typeof(IfStep).FullName)?.BaseType);
Assert.AreEqual(pkg.Files?.FirstOrDefault()?.Plugins.FirstOrDefault(p => p.Type == typeof(GenericScpiInstrument).FullName)?.BaseType, "Instrument");
}
public void CreatePackageDepVersions()
{
var tmp = Path.GetTempFileName();
var tmp2 = Path.GetTempFileName();
Directory.Move("Packages", "Packages2");
try
{
{
PackageDef def = new PackageDef();
def.Name = "test";
def.InfoLink = "a";
def.Date = DateTime.Today;
def.AddFile(tmp);
var bs = PluginManager.GetSearcher().Assemblies.First(asm => asm.Name == "OpenTap.Plugins.BasicSteps");
def.Files[0].DependentAssemblies.Add(bs);
var searcher = new PluginSearcher();
searcher.Search(Directory.GetCurrentDirectory());
List <AssemblyData> assemblies = searcher.Assemblies.ToList();
def.findDependencies(new List <string>(), assemblies);
Assert.AreEqual(0, def.Dependencies.Count);
Assert.AreNotEqual(0, def.Files.Count);
}
{
PackageDef def = new PackageDef();
def.AddFile(tmp);
var bs = PluginManager.GetSearcher().Assemblies.First(asm => asm.Name == "OpenTap.Plugins.BasicSteps");
def.Files[0].DependentAssemblies.Add(bs);
var searcher = new PluginSearcher();
searcher.Search(Directory.GetCurrentDirectory());
List <AssemblyData> assemblies = searcher.Assemblies.ToList();
def.findDependencies(new List <string> {
"OpenTap"
}, assemblies);
Assert.AreEqual(0, def.Dependencies.Count);
Assert.AreNotEqual(1, def.Files.Count);
}
}
finally
{
if (Directory.Exists("Packages"))
{
Directory.Delete("Packages", true);
}
Directory.Move("Packages2", "Packages");
}
}
public void DownloadPackage(IPackageIdentifier package, string destination, CancellationToken cancellationToken)
{
PackageDef packageDef = null;
// If the requested package is a file we do not want to start searching the entire repo.
if (package is PackageDef def && File.Exists((def.PackageSource as FilePackageDefSource)?.PackageFilePath))
{
log.Debug("Downloading file without searching repository.");
packageDef = def;
}
protected override int LockedExecute(CancellationToken cancellationToken)
{
if (Packages == null)
{
throw new Exception("No packages specified.");
}
if (Force == false && Packages.Any(p => p == "OpenTAP") && Target == ExecutorClient.ExeDir)
{
log.Error("Aborting request to uninstall the OpenTAP package that is currently executing as that would brick this installation. Use --force to uninstall anyway.");
return(-4);
}
Installer installer = new Installer(Target, cancellationToken)
{
DoSleep = false
};
installer.ProgressUpdate += RaiseProgressUpdate;
installer.Error += RaiseError;
var installedPackages = new Installation(Target).GetPackages();
bool anyUnrecognizedPlugins = false;
foreach (string pack in Packages)
{
PackageDef package = installedPackages.FirstOrDefault(p => p.Name == pack);
if (package != null && package.PackageSource is InstalledPackageDefSource source)
{
installer.PackagePaths.Add(source.PackageDefFilePath);
}
else if (!IgnoreMissing)
{
log.Error("Package '{0}' is not installed", pack);
anyUnrecognizedPlugins = true;
}
}
if (anyUnrecognizedPlugins)
{
return(-2);
}
if (!Force)
{
if (!CheckPackageAndDependencies(installedPackages, installer.PackagePaths))
{
return(-3);
}
}
return(installer.RunCommand("uninstall", Force, true) ? 0 : -1);
}
public void InstalledPackages_TwoPackages()
{
Assert.IsTrue(File.Exists(PackageDef.GetDefaultPackageMetadataPath("XSeries")), "Necessary package file missing.");
System.Collections.Generic.List <PackageDef> target = new Installation(Directory.GetCurrentDirectory()).GetPackages();
CollectionAssert.AllItemsAreInstancesOfType(target, typeof(PackageDef));
CollectionAssert.AllItemsAreNotNull(target);
CollectionAssert.AllItemsAreUnique(target);
Assert.IsTrue(target.Any(pkg => pkg.Name == "XSeries"));
Assert.IsTrue(target.Any(pkg => pkg.Name == "Test"));
}
public void CheckDependencies_AllDepsInstalled()
{
var xseries = PackageDef.FromXml(PackageDef.GetDefaultPackageMetadataPath("XSeries"));
//var test2 = PackageDef.FromXmlFile(PackageDef.GetDefaultPackageMetadataPath("Test2"));
File.Copy(PackageDef.GetDefaultPackageMetadataPath("CheckDependencies_AllDepsInstalled"), "CheckDependencies_AllDepsInstalled.xml", true);
PackageDef.ValidateXml("CheckDependencies_AllDepsInstalled.xml");
var alldeps = PackageDef.FromXml("CheckDependencies_AllDepsInstalled.xml");
//var tree = DependencyAnalyzer.BuildAnalyzerContext(new List<PackageDef> { xseries, test2, alldeps });
//Assert.AreEqual(tree.BrokenPackages.Count, 1);
//PackageDependencyExt.CheckDependencies(inputFilename);
}
public void CyclicDependenciesTest()
{
DummyPackageGenerator.InstallDummyPackage(); // We need to have "Dummy" installed before we can create a package that depends on it.
var depDef = new PackageDef();
depDef.Name = "Dependency";
depDef.OS = "Windows,Linux";
depDef.Version = SemanticVersion.Parse("1.0");
depDef.AddFile("Dependency.txt");
depDef.Dependencies.Add(new PackageDependency("Dummy", VersionSpecifier.Parse("1.0")));
string dep0File = DummyPackageGenerator.GeneratePackage(depDef);
DummyPackageGenerator.UninstallDummyPackage();
DummyPackageGenerator.InstallDummyPackage("Dependency");
var dummyDef = new PackageDef();
dummyDef.Name = "Dummy";
dummyDef.OS = "Windows,Linux";
dummyDef.Version = SemanticVersion.Parse("1.0");
dummyDef.AddFile("Dummy.txt");
dummyDef.Dependencies.Add(new PackageDependency("Dependency", VersionSpecifier.Parse("1.0")));
string dummyFile = DummyPackageGenerator.GeneratePackage(dummyDef);
DummyPackageGenerator.UninstallDummyPackage("Dependency");
try
{
if (File.Exists("Dependency.txt"))
{
File.Delete("Dependency.txt");
}
if (File.Exists("Dummy.txt"))
{
File.Delete("Dummy.txt");
}
int exitCode;
string output = RunPackageCli("install Dummy -y", out exitCode);
Assert.AreEqual(0, exitCode, "Unexpected exit code.\r\n" + output);
StringAssert.Contains("Dummy", output);
StringAssert.Contains("Dependency", output);
Assert.IsTrue(File.Exists("Dependency.txt"));
Assert.IsTrue(File.Exists("Dummy.txt"));
}
finally
{
PluginInstaller.Uninstall(dummyDef, Directory.GetCurrentDirectory());
PluginInstaller.Uninstall(depDef, Directory.GetCurrentDirectory());
File.Delete(dep0File);
File.Delete(dummyFile);
}
}
public void DependencyAnalyzerGetIssuesTest()
{
log.Info("-----------------------------DependencyAnalyzer GetIssues-----------------------------");
// Test setup.
var tapPackage = new PackageDef()
{
Name = "Tap", Version = SemanticVersion.Parse("7.0.700")
};
var packages = new List <PackageDef>();
packages.Add(tapPackage);
// Dependencies without any issues.
using (var xmlText = File.OpenRead(Path.Combine(Directory.GetCurrentDirectory(), "TapPackages/MyPlugin1.xml")))
packages.AddRange(PackageDef.ManyFromXml(xmlText));
var dependencyAnalyzer = DependencyAnalyzer.BuildAnalyzerContext(packages);
var issues = dependencyAnalyzer.GetIssues(packages.Last());
if (issues.Any())
{
Assert.Fail("Unexpected Dependency Issue: {1} {0} ", issues.First().IssueType, issues.First().PackageName);
}
log.Info("Dependencies without any issues - SUCCESS");
// Reset test.
packages = packages.Take(1).ToList();
// Dependencies with issues (Tap newer than plugin).
using (var xmlText = File.OpenRead(Path.Combine(Directory.GetCurrentDirectory(), "TapPackages/MyPlugin2.xml")))
{
var pkgs = PackageDef.ManyFromXml(xmlText);
packages.AddRange(pkgs);
Assert.IsTrue(pkgs.First().Version.Major == 1);
Assert.IsTrue(pkgs.First().Version.Minor == 2);
Assert.IsTrue(pkgs.First().Version.Patch == 3);
}
dependencyAnalyzer = DependencyAnalyzer.BuildAnalyzerContext(packages);
issues = dependencyAnalyzer.GetIssues(packages.Last());
Assert.IsTrue(issues.Count == 1, "Dependencies with issues (Tap newer than plugin)");
log.Info("Dependencies with issues (Tap newer than plugin) - SUCCESS");
// Reset test.
packages = packages.Take(1).ToList();
// No dependencies.
dependencyAnalyzer = DependencyAnalyzer.BuildAnalyzerContext(packages);
issues = dependencyAnalyzer.GetIssues(new PackageDef());
Assert.IsTrue(issues.Count == 0, "No dependencies");
log.Info("No dependencies - SUCCESS");
}
public void LoadPackageFile()
{
var packageString = Resources.GetEmbedded("ExamplePackage.xml");
PackageDef package;
using (var str = new MemoryStream(Encoding.UTF8.GetBytes(packageString)))
{
package = PackageDef.FromXml(str);
}
Assert.AreEqual(package.Dependencies.Count, 1);
Assert.AreEqual("Tap", package.Dependencies[0].Name);
Assert.AreEqual(package.Files.Count, 2);
Assert.IsNotNull(package.Description);
}
void Download(PackageDef packageDef, string nupkgCacheFilePath)
{
cacheCleanRequired = true;
var errors = new StringBuilder("Failed to download. This package may no longer exist on the nuget feed or there is a problem with your internet connection. Errors:");
var addresses = GetUrls(packageDef).ToList();
foreach (var address in addresses)
{
try
{
DownloadFromSpecificSource(nupkgCacheFilePath, address);
return;
}
catch (Exception ex)
{
errors.AppendLine(string.Format("Failed to download '{0}' due to '{1}'.", address, ex.Message));
}
}
throw new ExpectedException(errors.ToString());
}
string GetPackageCacheFile(PackageDef packageDef)
{
var nupkgCacheFilePath = Path.Combine(CachePath, string.Format("{0}.{1}.nupkg", packageDef.Id, packageDef.Version));
if (File.Exists(nupkgCacheFilePath))
{
WriteInfo("Found in cache " + nupkgCacheFilePath);
File.SetLastWriteTime(nupkgCacheFilePath, DateTime.Now);
return nupkgCacheFilePath;
}
Download(packageDef, nupkgCacheFilePath);
return nupkgCacheFilePath;
}
void ProcessPackageDef(PackageDef packageDef)
{
var packagePath = Path.Combine(PackagesPath, packageDef.Id + "." + packageDef.Version);
if (Directory.Exists(packagePath))
{
WriteInfo("Already exists so skipped " + packagePath);
return;
}
var packageCacheFile = GetPackageCacheFile(packageDef);
Directory.CreateDirectory(packagePath);
try
{
var nupkgFilePath = Path.Combine(packagePath, string.Format("{0}.{1}.nupkg", packageDef.Id, packageDef.Version));
// Resolve relative paths
nupkgFilePath = Path.GetFullPath(nupkgFilePath);
if (Directory.Exists(nupkgFilePath))
{
return;
}
File.Copy(packageCacheFile, nupkgFilePath, true);
ProcessPackage(packagePath, nupkgFilePath);
}
catch (Exception)
{
Directory.Delete(packagePath, true);
throw;
}
}
