using System;
|
using System.Collections.Generic;
|
using System.IO;
|
using System.Linq;
|
using System.Threading;
|
using System.Xml;
|
using NUnit.Framework;
|
using OpenTap.Diagnostic;
|
|
namespace OpenTap.Package.UnitTests
|
{
|
public class PackageCreateIncludeDependenciesTest
|
{
|
[SetUp]
|
public void SetUp()
|
{
|
var s = Session.Create();
|
sessionListener.Value = new TestLogListener();
|
Log.AddListener(sessionListener.Value);
|
sessionVariable.Value = s;
|
}
|
|
[TearDown]
|
public void TearDown()
|
{
|
sessionVariable.Value.Dispose();
|
}
|
|
private readonly SessionLocal<Session> sessionVariable = new SessionLocal<Session>();
|
private readonly SessionLocal<TestLogListener> sessionListener = new SessionLocal<TestLogListener>();
|
private TestLogListener Listener => sessionListener.Value;
|
|
private class TestLogListener : ILogListener
|
{
|
public List<Event> Events = new List<Event>();
|
|
public void EventsLogged(IEnumerable<Event> events)
|
{
|
Events.AddRange(events);
|
}
|
|
public void Flush()
|
{
|
}
|
|
public override string ToString()
|
{
|
return string.Join("\n", Events.Select(e => e.Message));
|
}
|
|
public bool AnyContains(string msg)
|
{
|
return Events.Any(e => e.Message.Contains(msg));
|
}
|
|
public void AssertContains(string msg)
|
{
|
Assert.IsTrue(AnyContains(msg), ToString());
|
}
|
|
public void AssertDoesNotContain(string msg)
|
{
|
Assert.IsFalse(AnyContains(msg), ToString());
|
}
|
|
public int Count(string msg)
|
{
|
return Events.Count(e => e.Message.Contains(msg));
|
}
|
}
|
|
private class PackageDep
|
{
|
public string Name { get; }
|
public string Version { get; }
|
|
public PackageDep(string name, string version)
|
{
|
Name = name;
|
Version = version;
|
}
|
}
|
private class FileDep
|
{
|
public FileDep(string content, bool includeDeps)
|
{
|
Content = content;
|
IncludeDeps = includeDeps;
|
}
|
|
public string Content { get; set; }
|
public bool IncludeDeps { get; set; }
|
}
|
|
private string BuildTestPlan(params PackageDep[] dependencies)
|
{
|
var xmlBase = @"<?xml version=""1.0"" encoding=""utf-8""?>
|
<TestPlan type=""OpenTap.TestPlan"" Locked=""false"">
|
<Package.Dependencies>
|
</Package.Dependencies>
|
</TestPlan>";
|
var node = new XmlDocument();
|
node.LoadXml(xmlBase);
|
var depTag = node.GetElementsByTagName("Package.Dependencies")[0];
|
|
foreach (var dependency in dependencies)
|
{
|
var pkg = node.CreateElement("Package");
|
pkg.SetAttribute("Name", dependency.Name);
|
if (dependency.Version != null)
|
pkg.SetAttribute("Version", dependency.Version);
|
|
depTag.AppendChild(pkg);
|
}
|
|
return node.OuterXml;
|
}
|
private string CreatePackageXml(params FileDep[] files)
|
{
|
var packageDefInput = $@"<?xml version=""1.0"" encoding=""UTF-8""?>
|
<Package Name=""TestPackage""
|
Version=""1.0.0""
|
OS=""Windows,Linux"">
|
<Files>
|
</Files>
|
</Package>
|
";
|
var node = new XmlDocument();
|
node.LoadXml(packageDefInput);
|
var fileTag = node.GetElementsByTagName("Files")[0];
|
|
foreach (var file in files)
|
{
|
var tmp = Path.GetTempFileName();
|
File.WriteAllText(tmp, file.Content);
|
|
var ele = node.CreateElement("File");
|
ele.SetAttribute("Path", tmp);
|
|
if (file.IncludeDeps)
|
{
|
var includeDeps = node.CreateElement("IncludePackageDependencies");
|
ele.AppendChild(includeDeps);
|
}
|
fileTag.AppendChild(ele);
|
}
|
|
var packageXml = Path.GetTempFileName();
|
node.Save(packageXml);
|
|
return packageXml;
|
}
|
|
|
private PackageDef BuildPackage(string packageXml)
|
{
|
var outFile = Path.GetTempFileName();
|
File.Delete(outFile);
|
var act = new PackageCreateAction {PackageXmlFile = packageXml, OutputPaths = new[] {outFile}};
|
act.Execute(CancellationToken.None);
|
return PackageDef.FromPackage(outFile);
|
}
|
|
[Test]
|
public void DependenciesAddedTest([Values(true, false)] bool AddDependency, [Values("any", null)] string Version)
|
{
|
var plan1 = BuildTestPlan(new PackageDep("P1", Version));
|
var packageXml = CreatePackageXml(new FileDep(plan1, AddDependency));
|
|
try
|
{
|
var pkg = BuildPackage(packageXml);
|
|
if (AddDependency)
|
{
|
Assert.AreEqual(1, pkg.Dependencies.Count);
|
StringAssert.AreEqualIgnoringCase(pkg.Dependencies.First().RawVersion, "any");
|
StringAssert.AreEqualIgnoringCase(pkg.Dependencies.First().Name, "P1");
|
}
|
else
|
{
|
Assert.AreEqual(0, pkg.Dependencies.Count);
|
}
|
}
|
catch (Exception ex)
|
{
|
Assert.Fail($"Unexpected exception: {ex.Message}");
|
}
|
}
|
|
[Test]
|
public void ConflictingDependenciesTest()
|
{
|
var version1 = VersionSpecifier.Parse("1.0.0");
|
var version2 = VersionSpecifier.Parse("2.0.0");
|
|
var plan1 = BuildTestPlan(
|
new PackageDep("P1", version1.ToString()),
|
new PackageDep("P1", version2.ToString()));
|
var packageXml = CreatePackageXml(new FileDep(plan1, true));
|
|
var pkg = BuildPackage(packageXml);
|
Listener.AssertContains("mutually exclusive");
|
Listener.AssertContains("Dependency conflict");
|
}
|
|
[Test]
|
public void BumpedDependenciesTest()
|
{
|
var version1 = VersionSpecifier.Parse("1.1.0");
|
var version2 = VersionSpecifier.Parse("1.2.0");
|
var version3 = VersionSpecifier.Any;
|
|
var plan1 = BuildTestPlan(
|
new PackageDep("P1", version1.ToString()),
|
new PackageDep("P2", version2.ToString()));
|
|
var plan2 = BuildTestPlan(
|
new PackageDep("P2", version1.ToString()),
|
new PackageDep("P1", version2.ToString()));
|
|
var plan3 = BuildTestPlan(new PackageDep("P2", version3.ToString()),
|
new PackageDep("P1", version3.ToString()));
|
|
var packageXml = CreatePackageXml(new FileDep(plan3, true), new FileDep(plan2, true), new FileDep(plan1, true));
|
var pkg = BuildPackage(packageXml);
|
|
Assert.IsTrue(pkg.Dependencies.Any(d => d.Name == "P1" && d.RawVersion == "^1.2.0" && d.Version.ToString() == "^1.2.0"));
|
Assert.IsTrue(pkg.Dependencies.Any(d => d.Name == "P2" && d.RawVersion == "^1.2.0" && d.Version.ToString() == "^1.2.0"));
|
}
|
|
[Test]
|
public void EmptyNameGeneratesException()
|
{
|
var version = VersionSpecifier.Any;
|
var plan = BuildTestPlan(new PackageDep("", version.ToString()));
|
|
var packageXml = CreatePackageXml(new FileDep(plan, true));
|
|
var pkg = BuildPackage(packageXml);
|
|
Listener.AssertContains("Attribute 'Name' is not set");
|
}
|
|
[Test]
|
public void InvalidVersionGeneratesException()
|
{
|
var plan = BuildTestPlan(new PackageDep("P1", "abc123"));
|
var packageXml = CreatePackageXml(new FileDep(plan, true));
|
|
var pkg = BuildPackage(packageXml);
|
Listener.AssertContains("Attribute 'Version' is not a valid version specifier");
|
}
|
|
[Test]
|
public void TestInvalidXml()
|
{
|
var plan = "Some string which is definitely not a valid XML document";
|
var packageXml = CreatePackageXml(new FileDep(plan, true));
|
|
var pkg = BuildPackage(packageXml);
|
|
Listener.AssertContains("is not a valid XML document.");
|
}
|
}
|
}
|
