// Copyright Keysight Technologies 2012-2019
|
// This Source Code Form is subject to the terms of the Mozilla Public
|
// License, v. 2.0. If a copy of the MPL was not distributed with this
|
// file, you can obtain one at http://mozilla.org/MPL/2.0/.
|
using NUnit.Framework;
|
using System.IO;
|
using System.Diagnostics;
|
using System.Text.RegularExpressions;
|
using System.Linq;
|
using System.Collections.Generic;
|
using OpenTap.Plugins.BasicSteps;
|
using System.Reflection;
|
using System;
|
using System.Runtime.Loader;
|
using System.Text;
|
using System.Xml;
|
using OpenTap.Cli;
|
using OpenTap.Engine.UnitTests.TestTestSteps;
|
using static OpenTap.Package.PackageDefExt;
|
using System.Threading;
|
|
namespace OpenTap.Package.UnitTests
|
{
|
internal static class ReflectionHelper
|
{
|
static Dictionary<MemberInfo, DisplayAttribute> displayLookup = new Dictionary<MemberInfo, DisplayAttribute>();
|
|
public static DisplayAttribute GetDisplayAttribute(this MemberInfo type)
|
{
|
if (!displayLookup.ContainsKey(type))
|
{
|
DisplayAttribute attr;
|
try
|
{
|
attr = type.GetCustomAttributes<DisplayAttribute>().FirstOrDefault();
|
}
|
catch
|
{ // This might happen for outdated plugins where an Attribute type ceased to exist.
|
attr = null;
|
}
|
|
if (attr == null)
|
{
|
attr = new DisplayAttribute(type.Name, null, Order: -10000, Collapsed: false);
|
}
|
|
displayLookup[type] = attr;
|
}
|
|
return displayLookup[type];
|
}
|
}
|
|
[TestFixture]
|
public class PackageDefTests
|
{
|
[Test]
|
public void MetaDataTest()
|
{
|
var package = new PackageDef();
|
package.Name = "test";
|
package.Version = SemanticVersion.Parse("1.0.0");
|
package.MetaData.Add("Kind", "UnitTest");
|
package.MetaData.Add("Test", "Value");
|
|
using (var stream = new MemoryStream())
|
{
|
package.SaveTo(stream);
|
package = null;
|
|
// Save the package to xml
|
stream.Seek(0, 0);
|
stream.Position = 0;
|
string xml = new StreamReader(stream).ReadToEnd();
|
Assert.IsNotNull(xml);
|
Assert.IsNotEmpty(xml);
|
|
// Check xml contains the right elements
|
var doc = new XmlDocument();
|
doc.LoadXml(xml);
|
var packageNode = doc.DocumentElement;
|
Assert.NotNull(packageNode);
|
Assert.IsTrue(packageNode.HasChildNodes);
|
Assert.IsTrue(packageNode.ChildNodes.Count == 2);
|
Assert.IsTrue(packageNode.FirstChild.Name == "Kind");
|
Assert.IsTrue(packageNode.LastChild.Name == "Test");
|
|
// Load the package from xml
|
stream.Seek(0, 0);
|
stream.Position = 0;
|
package = PackageDef.FromXml(stream);
|
|
Assert.NotNull(package);
|
Assert.IsTrue(package.MetaData.ContainsKey("Kind") && package.MetaData["Kind"] == "UnitTest");
|
Assert.IsTrue(package.MetaData.ContainsKey("Test") && package.MetaData["Test"] == "Value");
|
}
|
}
|
|
[Test]
|
public void MetaDataOverriding()
|
{
|
var package = new PackageDef();
|
package.Name = "test";
|
package.Version = SemanticVersion.Parse("1.0.0");
|
package.MetaData.Add("Description", "Something that should not be added.");
|
|
using (var stream = new MemoryStream())
|
{
|
Assert.Catch<ExitCodeException>(() => package.SaveTo(stream));
|
}
|
}
|
|
[TestCase("GlobTest/**/*.txt", 4)]
|
[TestCase("GlobTest/*/*.txt", 3)]
|
[TestCase("GlobTest/dir*/*.txt", 3)]
|
[TestCase("GlobTest/dir?/*.txt", 3)]
|
[TestCase("GlobTest/**/dir3/*.txt",1)]
|
[TestCase("GlobTest/*/dir3/*.txt", 1)]
|
[TestCase("GlobTes?/dir1/*.txt", 1)]
|
[TestCase("GlobTest/empty/*.txt", 0)]
|
[TestCase("GlobTest/nonexistent/*.txt", 0)]
|
[TestCase("GlobTest/empty/*.txt,GlobTest/dir2/*.txt", 2)]
|
public void GlobTest(string globPattern, int matchCount)
|
{
|
Directory.CreateDirectory("GlobTest");
|
Directory.CreateDirectory("GlobTest/dir1");
|
Directory.CreateDirectory("GlobTest/dir2");
|
Directory.CreateDirectory("GlobTest/dir2/dir3");
|
Directory.CreateDirectory("GlobTest/empty");
|
File.WriteAllText("GlobTest/dir1/inDir1.txt","test");
|
File.WriteAllText("GlobTest/dir2/inDir2.txt","test");
|
File.WriteAllText("GlobTest/dir2/inDir2Too.txt", "test");
|
File.WriteAllText("GlobTest/dir2/dir3/inDir3.txt", "test");
|
|
try
|
{
|
List<PackageFile> files = new List<PackageFile>
|
{
|
new PackageFile{ RelativeDestinationPath = "FirstEntry.txt" }
|
};
|
foreach(var x in globPattern.Split(','))
|
{
|
files.Add(new PackageFile { RelativeDestinationPath = x });
|
}
|
|
files.Add(new PackageFile { RelativeDestinationPath = "LastEntry.txt" });
|
|
files = PackageDefExt.expandGlobEntries(files);
|
Assert.AreEqual("FirstEntry.txt", files.First().RelativeDestinationPath);
|
Assert.AreEqual("LastEntry.txt", files.Last().RelativeDestinationPath);
|
Assert.AreEqual(matchCount, files.Count-2);
|
}
|
finally
|
{
|
FileSystemHelper.DeleteDirectory("GlobTest");
|
}
|
}
|
|
[Test]
|
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 == "OpenTap.Plugins.BasicSteps.GenericScpiInstrument")?.BaseType, "Instrument");
|
}
|
|
[Test]
|
[TestCase("da-DK")]
|
[TestCase("en-US")]
|
public void GetPluginOrder_Test_CultureIndependent(string cultureName)
|
{
|
var initialCulture = Thread.CurrentThread.CurrentCulture;
|
try
|
{
|
Thread.CurrentThread.CurrentCulture = new System.Globalization.CultureInfo(cultureName);
|
string inputFilename = "Packages/PackagePluginOrder/package.xml";
|
PackageDef pkg = PackageDefExt.FromInputXml(inputFilename, Directory.GetCurrentDirectory());
|
|
Assert.AreEqual(9.58, pkg.Files[0].Plugins[0].Order);
|
}
|
finally
|
{
|
Thread.CurrentThread.CurrentCulture = initialCulture;
|
}
|
}
|
|
[Test]
|
public void FromXmlFile_Test()
|
{
|
string inputFilename = "Packages/Package/package.xml";
|
|
PackageDef pkg = PackageDefExt.FromInputXml(inputFilename, Directory.GetCurrentDirectory());
|
//Assert.AreEqual(inputFilename, pkg.FileName);
|
|
CollectionAssert.IsNotEmpty(pkg.Files);
|
Assert.AreEqual("OpenTap.dll", pkg.Files[0].FileName);
|
Assert.AreEqual("Version", pkg.Files[0].GetCustomData<SetAssemblyInfoData>().FirstOrDefault().Attributes);
|
|
CollectionAssert.IsNotEmpty(pkg.PackageActionExtensions);
|
Assert.AreEqual("chmod", pkg.PackageActionExtensions[0].ExeFile);
|
Assert.AreEqual("install", pkg.PackageActionExtensions[0].ActionName);
|
Assert.AreEqual("+x tap", pkg.PackageActionExtensions[0].Arguments);
|
|
CollectionAssert.IsNotEmpty(pkg.Dependencies);
|
|
}
|
|
[Test]
|
public void GitVersionDependency()
|
{
|
string inputFilename = "GitVersionDependency-package.xml";
|
string outputFilename = "GitversionDependency.TapPlugin";
|
try
|
{
|
DummyPackageGenerator.InstallDummyPackage("DepName", new GitVersionCalulator(Directory.GetCurrentDirectory()).GetVersion().ToString() );
|
PackageDef pkg = PackageDefExt.FromInputXml(inputFilename, Directory.GetCurrentDirectory());
|
using (var file = CreateStream(outputFilename))
|
pkg.CreatePackage(file);
|
Assert.AreNotSame("$(GitVersion)", pkg.Dependencies.First().Version.ToString());
|
VersionSpecifier versionSpecifier = new VersionSpecifier(pkg.Version, VersionMatchBehavior.Exact);
|
|
Assert.AreEqual(pkg.Dependencies.FirstOrDefault(p => p.Name == "DepName").Version.ToString(), versionSpecifier.ToString());
|
}
|
finally
|
{
|
DummyPackageGenerator.UninstallDummyPackage("DepName");
|
if (File.Exists(outputFilename))
|
File.Delete(outputFilename);
|
}
|
}
|
|
[Test]
|
public void CreatePackage_NoObfuscation()
|
{
|
string inputFilename = "Packages/Package/package.xml";
|
string outputFilename = "Test.TapPlugin";
|
|
PackageDef pkg = PackageDefExt.FromInputXml(inputFilename, Directory.GetCurrentDirectory());
|
try
|
{
|
using(var file = CreateStream(outputFilename))
|
pkg.CreatePackage(file);
|
Assert.IsTrue(File.Exists(outputFilename));
|
}
|
finally
|
{
|
if (File.Exists(outputFilename))
|
File.Delete(outputFilename);
|
}
|
}
|
|
private static FileStream CreateStream(string outputFilename) => new FileStream(outputFilename, FileMode.Create,
|
FileAccess.ReadWrite, FileShare.ReadWrite, 4096);
|
|
[Test]
|
public void CreatePackage_NoBinFiles()
|
{
|
File.Copy("Packages/Package_NoBinFiles/package.xml", "package_NoBinFiles.xml", true);
|
string inputFilename = "package_NoBinFiles.xml";
|
string outputFilename = "Test.TapPackage";
|
|
PackageDef pkg = PackageDefExt.FromInputXml(inputFilename, Directory.GetCurrentDirectory());
|
try
|
{
|
using(var file = CreateStream(outputFilename))
|
pkg.CreatePackage(file);
|
Assert.IsTrue(File.Exists(outputFilename));
|
}
|
finally
|
{
|
if (File.Exists(outputFilename))
|
File.Delete(outputFilename);
|
}
|
}
|
|
[Test]
|
public void CreatePackageVersioningMono()
|
{
|
var tmpFile = Path.GetTempFileName();
|
File.Copy("OpenTap.dll", tmpFile, true);
|
|
SetAsmInfo.SetAsmInfo.SetInfo(tmpFile, new Version("1.2.3"), new Version("4.5.6"), SemanticVersion.Parse("0.1.2"));
|
|
// Side loading assemblies with different versions is not supported in netcore
|
// Load the dll in a new context instead. If we load it in the current context,
|
// the currently loaded OpenTAP.dll will be returned instead
|
var ctx = new AssemblyLoadContext("tmp");
|
var asm = ctx.LoadFromAssemblyPath(tmpFile);
|
Assert.AreEqual(1, asm.GetName().Version.Major, "Wrong major");
|
Assert.AreEqual(2, asm.GetName().Version.Minor, "Wrong minor");
|
Assert.AreEqual(3, asm.GetName().Version.Build, "Wrong build");
|
|
Assert.AreEqual("4.5.6", asm.GetCustomAttribute<AssemblyFileVersionAttribute>().Version, "File version");
|
Assert.AreEqual("0.1.2", asm.GetCustomAttribute<AssemblyInformationalVersionAttribute>().InformationalVersion, "Informational version");
|
|
Assert.AreEqual("4.5.6", FileVersionInfo.GetVersionInfo(tmpFile).FileVersion, "GetVersionInfo().FileVersion");
|
Assert.AreEqual("0.1.2", FileVersionInfo.GetVersionInfo(tmpFile).ProductVersion, "GetVersionInfo().ProductVersion");
|
Assert.AreEqual("0.1.2", FileSystemHelper.GetAssemblyVersion(tmpFile), "FileSystemHelper.GetAssemblyVersion");
|
}
|
|
[Test]
|
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");
|
}
|
}
|
|
[Test]
|
[Platform(Exclude="Unix,Linux,MacOsX")]
|
public void CreatePackageDepReuse()
|
{
|
if (Directory.Exists("Packages2"))
|
Directory.Delete("Packages2", true);
|
|
Directory.Move("Packages", "Packages2");
|
File.Copy("Packages2/DependencyTest.dll", "DependencyTest.dll", true);
|
|
try
|
{
|
Directory.CreateDirectory("Packages");
|
|
{
|
PackageDef def = new PackageDef() { Name = "pkg1", Version = SemanticVersion.Parse("1.2") };
|
def.AddFile("OpenTap.dll");
|
Directory.CreateDirectory("Packages/pkg1");
|
using (var f = File.OpenWrite("Packages/pkg1/package.xml")) def.SaveTo(f);
|
}
|
|
{
|
PackageDef def = new PackageDef() { Name = "gui", Version = SemanticVersion.Parse("1.2") };
|
def.AddFile("Keysight.OpenTap.Wpf.dll");
|
Directory.CreateDirectory("Packages/gui");
|
using (var f = File.OpenWrite("Packages/gui/package.xml")) def.SaveTo(f);
|
}
|
|
{
|
PackageDef def = new PackageDef() { Name = "rv", Version = SemanticVersion.Parse("1.2") };
|
def.AddFile("Keysight.OpenTap.Wpf.dll");
|
Directory.CreateDirectory("Packages/rv");
|
using (var f = File.OpenWrite("Packages/rv/package.xml")) def.SaveTo(f);
|
}
|
|
{
|
PackageDef def = new PackageDef();
|
def.Name = "test";
|
def.InfoLink = "a";
|
def.Date = DateTime.Today;
|
|
def.Dependencies.Add(new PackageDependency( "rv", VersionSpecifier.Parse("1.2")));
|
|
def.AddFile("DependencyTest.dll");
|
def.Files[0].DependentAssemblies.AddRange(PluginManager.GetSearcher().Assemblies.First(f => f.Name == "DependencyTest").References);
|
|
var searcher = new PluginSearcher();
|
searcher.Search(Directory.GetCurrentDirectory());
|
List<AssemblyData> assemblies = searcher.Assemblies.ToList();
|
def.findDependencies(new List<string>(), assemblies);
|
|
//Assert.AreEqual(3, def.Dependencies.Count);
|
Assert.IsTrue(def.Dependencies.Any(d => d.Name == "rv"));
|
Assert.IsTrue(def.Dependencies.Any(d => d.Name == "pkg1"));
|
}
|
|
{
|
PackageDef def = new PackageDef();
|
def.Name = "test";
|
def.InfoLink = "a";
|
def.Date = DateTime.Today;
|
|
def.Dependencies.Add(new PackageDependency("gui", VersionSpecifier.Parse("1.2") ));
|
|
def.AddFile("DependencyTest.dll");
|
def.Files[0].DependentAssemblies.AddRange(PluginManager.GetSearcher().Assemblies.First(f => f.Name == "DependencyTest").References);
|
|
var searcher = new PluginSearcher();
|
searcher.Search(Directory.GetCurrentDirectory());
|
List<AssemblyData> assemblies = searcher.Assemblies.ToList();
|
def.findDependencies(new List<string>(), assemblies);
|
|
//Assert.AreEqual(2, def.Dependencies.Count);
|
Assert.IsTrue(def.Dependencies.Any(d => d.Name == "gui"));
|
Assert.IsTrue(def.Dependencies.Any(d => d.Name == "pkg1"));
|
}
|
}
|
finally
|
{
|
if (Directory.Exists("Packages"))
|
Directory.Delete("Packages", true);
|
Directory.Move("Packages2", "Packages");
|
}
|
}
|
|
[Test]
|
public void SaveTo_Simple()
|
{
|
string inputFilename = "Packages/Package/package.xml"; // this package contains the old XML Schema URL
|
string outputFileContent = "";
|
|
PackageDef pkg = PackageDef.FromXml(inputFilename);
|
|
using (Stream str = new MemoryStream())
|
{
|
pkg.SaveTo(str);
|
using (StreamReader reader = new StreamReader(str))
|
{
|
reader.BaseStream.Seek(0, 0);
|
outputFileContent = reader.ReadToEnd();
|
}
|
}
|
string inputContent = File.ReadAllText(inputFilename);
|
// check that the package now contains the new XML Schema URL
|
StringAssert.Contains("xmlns=\"http://opentap.io/schemas/package\"", outputFileContent);
|
}
|
|
[Test]
|
public void SaveManyTo_Simple()
|
{
|
string outputFileContent = "";
|
|
PackageDef pkg = PackageDefExt.FromInputXml("Packages/Package/package.xml", Directory.GetCurrentDirectory());
|
PackageDef pkg1 = PackageDefExt.FromInputXml("Packages/test2/package.xml", Directory.GetCurrentDirectory());
|
|
using (Stream str = new MemoryStream())
|
{
|
PackageDef.SaveManyTo(str, new List<PackageDef> { pkg, pkg1 });
|
using (StreamReader reader = new StreamReader(str))
|
{
|
reader.BaseStream.Seek(0, 0);
|
outputFileContent = reader.ReadToEnd();
|
}
|
}
|
// check that the package now contains the new XML Schema URL
|
StringAssert.Contains("xmlns=\"http://opentap.io/schemas/package\"", outputFileContent);
|
Assert.AreEqual(2, Regex.Matches(outputFileContent, "xmlns").Count);
|
}
|
|
[Test]
|
public void SaveTo_FromXmlFile_Dependency()
|
{
|
string inputXml = @"<?xml version='1.0' encoding='utf-8' ?>
|
<Package Name='Test3' xmlns ='http://opentap.io/schemas/package'>
|
<Files>
|
<File Path='OpenTap.Package.UnitTests.dll'>
|
<UseVersion/>
|
</File>
|
</Files>
|
</Package>
|
";
|
string inputFilename = "test3.package.xml";
|
File.WriteAllText(inputFilename,inputXml);
|
string outputFileContent = "";
|
|
PackageDef pkg = PackageDefExt.FromInputXml(inputFilename, Directory.GetCurrentDirectory());
|
pkg.Files.First().IgnoredDependencies.AddRange(new[] { "abc", "test" });
|
|
using (Stream str = new MemoryStream())
|
{
|
pkg.SaveTo(str);
|
using (StreamReader reader = new StreamReader(str))
|
{
|
reader.BaseStream.Seek(0, 0);
|
outputFileContent = reader.ReadToEnd();
|
}
|
}
|
|
StringAssert.Contains("<PackageDependency Package=\"Test1\" Version=\"^1.2", outputFileContent); // the Test2 package is a release version, so it should have 2 version numbers specified
|
//StringAssert.Contains("<PackageDependency Package=\"Test2\" Version=\"1.2.3", outputFileContent); // the Test2 package is from an integration branch, so it should have 3 version numbers specified
|
StringAssert.Contains("<PackageDependency Package=\"OpenTAP\"", outputFileContent);
|
StringAssert.Contains("<IgnoreDependency>test</IgnoreDependency>", outputFileContent);
|
|
// check that the dependency to XSeries is not there twice:
|
Assert.IsFalse(Regex.IsMatch(outputFileContent, "(Test1).+\n.+(Test1)"));
|
}
|
|
[Test]
|
public void findDependencies_SharedAssemblyReference()
|
{
|
// tap package create X --package-dir C:\MyPackages
|
|
string PackageInstallDir = "C:\\MyPackages\\";
|
var inst = new Installation(Directory.GetCurrentDirectory());
|
|
if (PackageInstallDir != null)
|
inst = new Installation(PackageInstallDir);
|
if (inst.GetPackages().Count() == 0)
|
inst = new Installation(System.IO.Path.GetDirectoryName(typeof(TestPlan).Assembly.Location));
|
|
|
var pkgs = inst.GetPackages();
|
string inputXml = @"<?xml version='1.0' encoding='utf-8' ?>
|
<Package Name='Test3' xmlns ='http://opentap.io/schemas/package'>
|
<Files>
|
<File Path='OpenTap.Package.UnitTests.dll'/>
|
</Files>
|
</Package>
|
";
|
string inputFilename = "test3.package.xml";
|
File.WriteAllText(inputFilename, inputXml);
|
|
PackageDef pkg = PackageDefExt.FromInputXml(inputFilename, Directory.GetCurrentDirectory());
|
|
// This package should depend on the OpenTAP package, since it contains OpenTAP.dll that OpenTap.Package.UnitTests.dll from this package needs
|
CollectionAssert.Contains(pkg.Dependencies.Select(d => d.Name),"OpenTAP");
|
}
|
|
[Test]
|
public void findDependencies_HardcodedDependency()
|
{
|
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='OpenTAP' Version='Any'/>
|
</Dependencies>
|
<Files>
|
<File Path='OpenTap.Package.UnitTests.dll'/>
|
</Files>
|
</Package>
|
";
|
string inputFilename = "test3.package.xml";
|
File.WriteAllText(inputFilename, inputXml);
|
|
PackageDef pkg = PackageDefExt.FromInputXml(inputFilename, Directory.GetCurrentDirectory());
|
|
// This package should depend on the OpenTAP package only once.
|
Assert.AreEqual(1, pkg.Dependencies.Count(d => d.Name == "OpenTAP"));
|
}
|
|
[Test]
|
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)PackageExitCodes.PackageDependencyError, ex.ExitCode);
|
}
|
}
|
|
[Test]
|
public void findDependencies_SharedAssemblyReferenceInDependencies()
|
{
|
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'>
|
<Files>
|
<File Path='System.Reflection.MetadataLoadContext.dll'/>
|
</Files>
|
</Package>
|
";
|
string inputFilename = "test3.package.xml";
|
File.WriteAllText(inputFilename, inputXml);
|
|
PackageDef pkg = PackageDefExt.FromInputXml(inputFilename, Directory.GetCurrentDirectory());
|
|
// This package should not depend on the OpenTAP package, event though it contains System.Collections.Immutable.dll that System.Reflection.Metadata.dll from this package needs
|
CollectionAssert.DoesNotContain(pkg.Dependencies.Select(d => d.Name), "OpenTAP");
|
}
|
|
static string GetEmbeddedFile(string file)
|
{
|
var resourceName = Assembly.GetCallingAssembly().GetName().Name + "." + file.Replace("/", ".");
|
var stream = Assembly.GetCallingAssembly()
|
.GetManifestResourceStream(resourceName);
|
return new StreamReader(stream).ReadToEnd();
|
}
|
|
/// <summary>
|
/// This test requires that OpenTAP is installed along with the XSeries plugin
|
/// </summary>
|
[Test]
|
public void CheckDependencies_MissingDep()
|
{
|
|
string xSeriesPath = "Packages/XSeries/package.xml";
|
string inputFilename = "Packages/CheckDependencies_MissingDep/package.xml";
|
var xml= GetEmbeddedFile(inputFilename);
|
var xSeriesXml = GetEmbeddedFile(xSeriesPath);
|
FileSystemHelper.EnsureDirectoryOf(xSeriesPath);
|
FileSystemHelper.EnsureDirectoryOf(inputFilename);
|
File.WriteAllText(xSeriesPath, xSeriesXml);
|
File.WriteAllText(inputFilename, xml);
|
try
|
{
|
|
//PackageDependencyExt.CheckDependencies(inputFilename);
|
var xseries = PackageDef.FromXml(xSeriesPath);
|
PackageDef.ValidateXml(inputFilename);
|
var missing = PackageDef.FromXml(inputFilename);
|
var tree = DependencyAnalyzer.BuildAnalyzerContext(new List<PackageDef> {xseries, missing});
|
Assert.IsTrue(tree.GetIssues(missing).Any(issue => issue.IssueType == DependencyIssueType.Missing));
|
}
|
finally
|
{
|
FileSystemHelper.DeleteDirectory(Path.GetDirectoryName(xSeriesPath));
|
FileSystemHelper.DeleteDirectory(Path.GetDirectoryName(inputFilename));
|
}
|
//Assert.Fail("CheckDependencies should have thrown an exception");
|
}
|
|
|
[Test]
|
[Ignore("Temporarily Disabled")]
|
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"));
|
}
|
|
[Test]
|
[Ignore("Temporarily Disabled")]
|
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 static void EnsureDirectory(string filePath)
|
{
|
var dirname = Path.GetDirectoryName(filePath);
|
if (string.IsNullOrWhiteSpace(dirname))
|
return;
|
if (!Directory.Exists(dirname))
|
Directory.CreateDirectory(dirname);
|
}
|
|
[Test]
|
public void FileRepositoryManagerTest()
|
{
|
string pkgContent = @"<?xml version=""1.0"" encoding=""utf-8""?>
|
<Package Name=""BasicSteps"" xmlns=""http://keysight.com/schemas/TAP/Package"" OS=""Linux,Windows,MacOS"">
|
<Files>
|
<File Path=""__BASICSTEPS_DLL__"">
|
<UseVersion/>
|
</File>
|
</Files>
|
</Package>
|
".Replace("__BASICSTEPS_DLL__", Path.GetFileName(typeof(DelayStep).Assembly.Location));
|
string pkgName = "BasicSteps.xml";
|
|
try
|
{
|
if (File.Exists(pkgName))
|
File.Delete(pkgName);
|
File.WriteAllText(pkgName, pkgContent);
|
string installDir = Path.GetDirectoryName(typeof(Package.PackageDef).Assembly.Location);
|
var pkg = PackageDefExt.FromInputXml(pkgName, installDir);
|
CollectionAssert.IsNotEmpty(pkg.Dependencies,"Package has no dependencies.");
|
//Assert.AreEqual("OpenTAP", pkg.Dependencies.First().Name);
|
using(var file = CreateStream("BasicSteps.TapPackage"))
|
pkg.CreatePackage(file);
|
|
List<IPackageRepository> repositories = new List<IPackageRepository>() { new FilePackageRepository(installDir) };
|
|
var packages = PackageRepositoryHelpers.GetPackagesFromAllRepos(repositories, new PackageSpecifier());
|
CollectionAssert.IsNotEmpty(packages, "Repository does not list any packages.");
|
Assert.IsTrue(packages.Any(p => p.Name == "BasicSteps"));
|
|
|
var depVersion = pkg.Dependencies.First().Version;
|
var version = new SemanticVersion(depVersion.Major ?? 0, depVersion.Minor ?? 0, depVersion.Patch ?? 0, depVersion.PreRelease, "");
|
var depName = pkg.Dependencies.First().Name;
|
packages = PackageRepositoryHelpers.GetPackagesFromAllRepos(repositories, new PackageSpecifier("BasicSteps"), new PackageIdentifier(depName, version, CpuArchitecture.Unspecified, null));
|
CollectionAssert.IsNotEmpty(packages, "Repository does not list any compatible \"BasicSteps\" package.");
|
Assert.IsTrue(packages.First().Name == "BasicSteps");
|
}
|
finally
|
{
|
if (File.Exists("BasicSteps.TapPackage"))
|
File.Delete("BasicSteps.TapPackage");
|
if (File.Exists(pkgName))
|
File.Delete(pkgName);
|
}
|
}
|
|
[Test]
|
public void TestCliPackaging()
|
{
|
var p = Process.Start("tap", "package create \"Packages/Package/package.xml\" -v");
|
p.WaitForExit();
|
Assert.AreEqual(0, p.ExitCode);
|
var plugins = Directory.EnumerateFiles(".");
|
|
Assert.IsTrue(plugins.Any(package =>
|
Path.GetFileName(package).StartsWith("Test", System.StringComparison.OrdinalIgnoreCase) &&
|
Path.GetExtension(package).EndsWith("TapPackage", System.StringComparison.OrdinalIgnoreCase)
|
), "Generated OpenTAP package file not found");
|
}
|
|
/* XSeries not compiled for TAP 5.0.
|
[Test]
|
[DeploymentItem("package3.xml")]
|
[DeploymentItem("Keysight.TapPlugin.ResultListener.SqlDatabase.dll")]
|
[DeploymentItem("XSeries.2.3.0.9b084a8.TapPlugin")]
|
public void DublicateAssemblies()
|
{
|
// This test creates assemblies to test some complicated behaviour related to
|
// creating plugin packages.
|
|
var pkgpath = "XSeries.2.3.0.9b084a8.TapPlugin";
|
var files = PluginInstaller.FilesInPackage(pkgpath);
|
using (ZipPackage zip =(ZipPackage)ZipPackage.Open(pkgpath, FileMode.Open, FileAccess.Read, FileShare.Read))
|
{
|
foreach (var part in zip.GetParts())
|
{
|
try
|
{
|
string filePath = part.Uri.OriginalString.TrimStart('/');
|
EnsureDirectory(filePath);
|
using (var str = File.Create(filePath))
|
{
|
part.GetStream().CopyTo(str);
|
}
|
}
|
catch
|
{
|
|
}
|
}
|
}
|
CSharpCodeProvider provider = new CSharpCodeProvider();
|
CompilerParameters parameters = new CompilerParameters();
|
parameters.ReferencedAssemblies.Add("System.dll");
|
parameters.ReferencedAssemblies.Add("TapPlugin.XSignalAnalyzer.dll");
|
|
parameters.ReferencedAssemblies.Add("Keysight.Tap.Engine.dll");
|
parameters.GenerateInMemory = false;
|
parameters.GenerateExecutable = false;
|
parameters.OutputAssembly = "test1.dll";
|
var asmv = "[assembly: System.Reflection.AssemblyInformationalVersionAttribute(\"CAL10604_DVT10603.2.f2d1ee5\")]\n";
|
CompilerResults results = provider.CompileAssemblyFromSource(parameters, asmv + "public class Instr1:TapPlugin.XSignalAnalyzer.XsaCore {}");
|
parameters.OutputAssembly = "test2.dll";
|
parameters.ReferencedAssemblies.Add("TapPlugin.XSignalSource.dll");
|
parameters.ReferencedAssemblies.Remove("TapPlugin.XSignalAnalyzer.dll");
|
CompilerResults results2 = provider.CompileAssemblyFromSource(parameters, asmv + "public class Instr2:TapPlugin.XSignalSource.XsgCore {}");
|
var pkg = PackageDefExt.FromXmlFile("package3.xml", verbose: true);
|
Assert.AreEqual(1, pkg.Dependencies.Count);
|
Assert.AreEqual("XSeries", pkg.Dependencies.First().PackageName);
|
}*/
|
|
[Test]
|
[Platform(Exclude="Unix,Linux,MacOsX")]
|
public void TestSetAssemblyInfo()
|
{
|
File.Copy("Packages/SetAsmInfoTest.dll", "SetAsmInfoTest.dll", true);
|
var fileName = $"SetAsmInfoTest.dll";
|
|
// Check if version is null
|
Assert.IsNull(ReadAssemblyVersionStep.GetVersion(fileName), "Assembly version is not null as expected.");
|
|
// Check if version has been new version inserted
|
SetAsmInfo.SetAsmInfo.SetInfo(fileName, Version.Parse("1.2.3.4"), Version.Parse("2.3.4.5"), SemanticVersion.Parse("2.3.4-test"));
|
Assert.IsTrue(ReadAssemblyVersionStep.GetVersion(fileName)?.Equals(SemanticVersion.Parse("2.3.4-test")), "Assembly version was not inserted correctly.");
|
|
// Check if version has been updated.
|
SetAsmInfo.SetAsmInfo.SetInfo(fileName, Version.Parse("1.2.3.4"), Version.Parse("2.3.4.5"), SemanticVersion.Parse("3.4.5-test"));
|
Assert.IsTrue(ReadAssemblyVersionStep.GetVersion(fileName)?.Equals(SemanticVersion.Parse("3.4.5-test")), "Assembly version was not updated correctly.");
|
}
|
|
[Test]
|
public void PackageValidationTest()
|
{
|
var testDir = "metadatatest";
|
|
void ValidateXml(string pkg)
|
{
|
var xmlPath = Path.Combine(testDir, "package.xml");
|
if (File.Exists(xmlPath))
|
File.Delete(xmlPath);
|
|
File.WriteAllText(xmlPath, pkg);
|
|
PackageDef.ValidateXml(xmlPath);
|
}
|
|
try
|
{
|
Directory.CreateDirectory(testDir);
|
|
// Package with metadata
|
var package = @"<?xml version=""1.0"" encoding=""utf-8""?>
|
<Package Name=""testing"" Version=""1.0.0"" Architecture=""AnyCPU"" OS=""Windows"" xmlns=""http://opentap.io/schemas/package"">
|
<Something>testing</Something>
|
<Owner>testing</Owner>
|
</Package>";
|
Assert.DoesNotThrow(() => ValidateXml(package), "Package with metadata");
|
|
|
// Package with no name
|
package = @"<?xml version=""1.0"" encoding=""utf-8""?>
|
<Package Version=""1.0.0"" Architecture=""AnyCPU"" OS=""Windows"" xmlns=""http://opentap.io/schemas/package"" />";
|
Assert.Throws<InvalidDataException>(() => ValidateXml(package), "Package with no Name");
|
|
// Package with empty name
|
package = @"<?xml version=""1.0"" encoding=""utf-8""?>
|
<Package Name="""" Version=""1.0.0"" Architecture=""AnyCPU"" OS=""Windows"" xmlns=""http://opentap.io/schemas/package"" />";
|
Assert.Throws<InvalidDataException>(() => ValidateXml(package), "Package with no Name");
|
|
|
// Package with no version. Should not fail, we automatically set it in the serializer <see cref="PackageDefinitionSerializerPlugin"/>
|
package = @"<?xml version=""1.0"" encoding=""utf-8""?>
|
<Package Name=""testing"" Architecture=""AnyCPU"" OS=""Windows"" xmlns=""http://opentap.io/schemas/package"" />";
|
Assert.DoesNotThrow(() => ValidateXml(package), "Package with no version");
|
|
// Package with empty version. Should not fail, we automatically set it in the serializer <see cref="PackageDefinitionSerializerPlugin"/>
|
package = @"<?xml version=""1.0"" encoding=""utf-8""?>
|
<Package Name=""testing"" Version="""" Architecture=""AnyCPU"" OS=""Windows"" xmlns=""http://opentap.io/schemas/package"" />";
|
Assert.DoesNotThrow(() => ValidateXml(package), "Package with no version");
|
|
package = @"<?xml version=""1.0"" encoding=""utf-8""?>
|
<Package Name=""testing"" Version=""$(GitVersion)"" Architecture=""AnyCPU"" OS=""Windows"" xmlns=""http://opentap.io/schemas/package"" />";
|
Assert.DoesNotThrow(() => ValidateXml(package), "Package with macro version");
|
|
|
// Package with no OS. Should not fail, we set the Windows as default in the constructor.
|
package = @"<?xml version=""1.0"" encoding=""utf-8""?>
|
<Package Name=""testing"" Version=""1.0.0"" Architecture=""AnyCPU"" xmlns=""http://opentap.io/schemas/package"" />";
|
Assert.DoesNotThrow(() => ValidateXml(package), "Package with no OS");
|
|
// Package with empty OS
|
package = @"<?xml version=""1.0"" encoding=""utf-8""?>
|
<Package Name=""testing"" Version=""1.0.0"" Architecture=""AnyCPU"" OS="""" xmlns=""http://opentap.io/schemas/package"" />";
|
Assert.Throws<InvalidDataException>(() => ValidateXml(package), "Package with empty OS");
|
|
|
// Package with no Architecture. Should not fail, we set the AnyCPU as default in the constructor.
|
package = @"<?xml version=""1.0"" encoding=""utf-8""?>
|
<Package Name=""testing"" Version=""1.0.0"" OS=""Windows"" xmlns=""http://opentap.io/schemas/package"" />";
|
Assert.DoesNotThrow(() => ValidateXml(package), "Package with no Architecture");
|
|
// Package with empty Architecture
|
package = @"<?xml version=""1.0"" encoding=""utf-8""?>
|
<Package Name=""testing"" Version=""1.0.0"" OS=""Windows"" Architecture="""" xmlns=""http://opentap.io/schemas/package"" />";
|
Assert.Throws<ArgumentException>(() => ValidateXml(package), "Package with empty Architecture"); // Throws an ArgumentException from the serializer because enum must have a value
|
}
|
finally
|
{
|
try
|
{
|
Directory.Delete(testDir, true);
|
}
|
catch
|
{
|
// ignored
|
}
|
}
|
}
|
|
[Test]
|
public void ValidationMarkerTest()
|
{
|
var pkgDef = @"<?xml version=""1.0"" encoding=""utf-8"" ?>
|
<Package Name=""MarkerTest"" Version=""1.2.3+4"" xmlns=""http://opentap.io/schemas/package"">
|
<Files>
|
<File Path=""testfile.txt"">
|
</File>
|
</Files>
|
<Validation>
|
<FileExists Path=""markerfile.txt""/>
|
</Validation>
|
</Package>";
|
var pkg = PackageDef.FromXml(new MemoryStream(Encoding.UTF8.GetBytes(pkgDef)));
|
|
File.WriteAllText("markerfile.txt", "123");
|
bool isValid = pkg.IsValid();
|
Assert.IsTrue(isValid);
|
var stream = new MemoryStream();
|
pkg.SaveTo(stream);
|
var pkg2 = PackageDef.FromXml(new MemoryStream(stream.ToArray()));
|
bool isValid2 = pkg.IsValid();
|
Assert.IsTrue(isValid2);
|
Assert.AreEqual(1, pkg2.Validation.Count);
|
File.Delete("markerfile.txt");
|
Assert.IsFalse(pkg2.IsValid());
|
}
|
|
/// <summary>
|
/// Using an unknown validation tag should be the same as not having it.
|
/// </summary>
|
[Test]
|
public void UnknownValidationTest()
|
{
|
var pkgDef = @"<?xml version=""1.0"" encoding=""utf-8"" ?>
|
<Package Name=""MarkerTest"" Version=""1.2.3+4"" xmlns=""http://opentap.io/schemas/package"">
|
<Files>
|
<File Path=""testfile.txt"">
|
</File>
|
</Files>
|
<Validation>
|
<UnknownValidation Path=""markerfile.txt""/>
|
<FileExists Path=""markerfile.txt""/>
|
</Validation>
|
</Package>";
|
var pkg = PackageDef.FromXml(new MemoryStream(Encoding.UTF8.GetBytes(pkgDef)));
|
File.WriteAllText("markerfile.txt", "123");
|
Assert.IsTrue(pkg.IsValid());
|
File.Delete("markerfile.txt");
|
Assert.IsFalse(pkg.IsValid());
|
}
|
}
|
}
|
