//            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 OpenTap.Cli;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Text;
using System.Xml;

namespace OpenTap.Package.UnitTests
{
    static class DummyPackageGenerator
    {
        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);
        }

        public static void AddFile(this PackageDef def, string filename)
        {
            def.Files.Add(new PackageFile { RelativeDestinationPath = filename, Plugins = new List<PluginFile>() });
        }

        internal static void InstallDummyPackage(string packageName = "Dummy", string version = "1.0", string contentFileName = "Dummy")
        {
            string installDir = Path.GetDirectoryName(typeof(Package.PackageDef).Assembly.Location);
            string packageXmlPath = Path.Combine(installDir, "Packages", packageName, "package.xml");
            Directory.CreateDirectory(Path.Combine(installDir, "Packages", packageName));
            File.WriteAllText(packageXmlPath, $@"<?xml version='1.0' encoding='utf-8' ?>
<Package Name='{packageName}' Version='{version}' xmlns ='http://opentap.io/schemas/package'>
  <Files>
    <File Path='Packages/{packageName}/{contentFileName}.txt'/>
  </Files>
</Package>");
            string contentFilePath = Path.Combine(installDir, "Packages", packageName, contentFileName);
            if (!File.Exists(contentFilePath))
                File.WriteAllText(contentFilePath, "hello");
        }

        internal static void UninstallDummyPackage(string packageName = "Dummy")
        {
            string installDir = Path.GetDirectoryName(typeof(Package.PackageDef).Assembly.Location);
            string packageDir = Path.Combine(installDir, "Packages", packageName);
            if (Directory.Exists(packageDir))
            {
                Directory.Delete(packageDir, true);
            }
        }
    }

    [TestFixture]
    public class CliTests
    {
        [TestCase(true, true, null)]                 // tap package download --out /tmp/Nested/TargetDir/ pkg -r /tmp
        [TestCase(true, false, null)]                // tap package download --out /tmp/Nested/TargetDir/ /tmp/pkg.TapPackage
        [TestCase(true, true, "pkg.TapPackage")]     // tap package download --out /tmp/Nested/TargetDir/pkg.TapPackage pkg -r /tmp
        [TestCase(true, false, "pkg.TapPackage")]     // tap package download --out /tmp/Nested/TargetDir/pkg.TapPackage /tmp/pkg.TapPackage
        [TestCase(false, false, null)]               // tap package download /tmp/pkg.TapPackage
        [TestCase(false, true, null)]                // tap package download pkg -r /tmp
        public void DownloadTest(bool useOut, bool useRepo, string outFileName)
        {
            var depDef = new PackageDef {Name = "Pkg1", Version = SemanticVersion.Parse("1.0"), OS = "Windows,Linux,MacOS"};
            depDef.AddFile("Dependency.txt");
            string dep0File = DummyPackageGenerator.GeneratePackage(depDef);

            string tempFn = Path.Combine(Path.GetTempPath(), Path.GetFileName(dep0File));

            if (File.Exists(tempFn))
                File.Delete(tempFn);
            File.Move(dep0File, tempFn);

            string outArg = Path.Combine(Path.GetTempPath(), "Nested", "TargetDir" + Path.DirectorySeparatorChar);
            if (outFileName != null)
                outArg = Path.Combine(outArg, outFileName);

            string targetFile;
            // Expected output path differs depending on whether or not we specify --out
            if (useOut && outFileName == null)
                targetFile = Path.GetFullPath(Path.Combine(outArg, PackageActionHelpers.GetQualifiedFileName(depDef)));
            else if (useOut && outFileName != null)
                targetFile = Path.GetFullPath(outArg);
            else
                targetFile = Path.Combine(Path.GetDirectoryName(typeof(Package.PackageDef).Assembly.Location),
                    PackageActionHelpers.GetQualifiedFileName(depDef)); 
            try
            {

                var args = $"download ";
                if (useOut)
                    args += $" --out {outArg} ";
                
                if (useRepo)
                    args += $" {depDef.Name} -r {Path.GetDirectoryName(tempFn)} ";
                else
                    args += $" {Path.GetFileName(tempFn)} ";
                args += " --no-cache";

                string output = RunPackageCli(args, out var exitCode, Path.GetDirectoryName(tempFn));
                Assert.AreEqual(0, exitCode, "Unexpected exit code");
                StringAssert.Contains($@"Downloaded '{depDef.Name}' to '{targetFile}'.", output);
                Assert.IsTrue(File.Exists(targetFile));
            }
            finally
            {
                File.Delete(dep0File);
                File.Delete(tempFn);
                if (useOut && outFileName == null)
                    Directory.Delete(outArg, true);
                else
                    File.Delete(targetFile);
            }
        }
        
        [Test]
        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(PackageCacheHelper.PackageCacheDirectory, file)))
                File.Delete(Path.Combine(PackageCacheHelper.PackageCacheDirectory, file));
            File.Move(file, Path.Combine(PackageCacheHelper.PackageCacheDirectory, 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);
        }
        
        [Test]
        public void CheckInvalidPackageName()
        {
            // Check if name contains invalid character
            try
            {
                DummyPackageGenerator.GeneratePackage(new PackageDef(){Name = "Op/en:T\\AP"});
                Assert.Fail("Path contains invalid character");
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
                Assert.True(e.Message.Contains("invalid file path characters"));
            }
        }

        [TestCase(".test", 1, typeof(XmlException))]
        [TestCase("t-est", 2, typeof(Exception))]
        [TestCase("te st", 3, typeof(XmlException))]
        [TestCase("tes.t", 4, typeof(Exception))]
        [TestCase("1test", 1, typeof(XmlException))]
        [TestCase("test?", 5, typeof(XmlException))]
        public void CheckInvalidMetadata(string invalidMetadataKey, int index, Type exceptionType)
        {
            // Check if metadata contains invalid characters
            var package = new PackageDef()
            {
                Name = "test",
                MetaData = { {invalidMetadataKey,""} },
                Version = SemanticVersion.Parse("1.0.0")
            };

            try
            {
                DummyPackageGenerator.GeneratePackage(package);
            }
            catch (Exception e)
            {
                Assert.IsAssignableFrom(exceptionType, e);
                if (e is XmlException)
                    return;

                Assert.True(e.Message.Contains($"Found invalid character"), "Package metadata keys contains invalid");
                Assert.True(e.Message.Contains($" in package metadata key '{invalidMetadataKey}' at position {index}."), "Package metadata keys contains invalid");
            }
        }

        [Test]
        public void ListTest()
        {
            int exitCode;
            string output = RunPackageCli("list", out exitCode);
            Assert.AreEqual(0, exitCode, $"Unexpected exit code.{Environment.NewLine}{output}");
            StringAssert.Contains("OpenTAP ", output);
            Debug.Write(output);
        }

        [Test]
        public void ShowTest()
        {
            int exitCode;
            string output = RunPackageCli("show OpenTAP", out exitCode);
            Assert.AreEqual(0, exitCode, $"Unexpected exit code.{Environment.NewLine}{output}");
            StringAssert.Contains("OpenTAP", output);
            Debug.Write(output);
        }

        [Ignore("This does not work on build runners")]
        [Test]
        public void TAPUninstallSelfTest()
        {
            int exitCode;
            string testDir = "../UninstallOpenTAP";
            try
            {
                Directory.CreateDirectory(testDir);
                string output = RunPackageCli($"install Packages/OpenTAP.TapPackage --target {testDir} -f", out exitCode);
                Debug.Write(output);
                Assert.AreEqual(0, exitCode, "Unexpected exit code.\r\n" + output);
                Debug.Write("--------------------------------------------");
                string workingDir = Path.Combine(Directory.GetCurrentDirectory(), testDir);
                output = RunPackageCliWrapped($"uninstall OpenTAP -v", out exitCode, workingDir, Path.Combine(workingDir, "tap.exe"));
                Debug.Write(output);
                if (File.Exists(Path.Combine(testDir, "OpenTap.dll")) || File.Exists(Path.Combine(testDir, "OpenTap.Package.dll")) || Directory.Exists(Path.Combine(testDir, "Packages")))
                    Console.WriteLine(output);
                Assert.False(File.Exists(Path.Combine(testDir, "OpenTap.dll")), "OpenTap.dll was not deleted!");
                Assert.False(File.Exists(Path.Combine(testDir, "OpenTap.Package.dll")), "OpenTap.Package.dll was not deleted!");
                Assert.False(Directory.Exists(Path.Combine(testDir, "Packages")), "Packages directory was not deleted!");
            }
            finally
            {
                try
                {
                    Directory.Delete(testDir, true);
                }
                catch { }
            }
        }

        [Test]
        public void InstallOutsideTapDir()
        {
            var depDef = new PackageDef();
            depDef.Name = "Pkg1";
            depDef.Version = SemanticVersion.Parse("1.0");
            depDef.AddFile("Dependency.txt");
            depDef.OS = OperatingSystem.Current.Name;
            string dep0File = DummyPackageGenerator.GeneratePackage(depDef);
            
            string tempFn = Path.Combine(Path.GetTempPath(), Path.GetFileName(dep0File));

            if (File.Exists(tempFn))
                File.Delete(tempFn);
            File.Move(dep0File, tempFn);

            try
            {
                if (File.Exists("Dependency.txt"))
                    File.Delete("Dependency.txt");
                int exitCode;
                string output = RunPackageCli("install " + Path.GetFileName(tempFn), out exitCode, Path.GetDirectoryName(tempFn));
                Assert.AreEqual(0, exitCode, "Unexpected exit code");
                StringAssert.Contains("Installed Pkg1", output);
                Assert.IsTrue(File.Exists("Dependency.txt"));
                PluginInstaller.Uninstall(depDef, Directory.GetCurrentDirectory());
            }
            finally
            {
                File.Delete(dep0File);
                File.Delete(tempFn);
            }
        }

        [Test]
        public void InstallOutsideTapDirInSubDir()
        {
            var depDef = new PackageDef();
            depDef.Name = "Pkg1";
            depDef.Version = SemanticVersion.Parse("1.0");
            depDef.OS = OperatingSystem.Current.Name;
            depDef.AddFile("Dependency.txt");
            string dep0File = DummyPackageGenerator.GeneratePackage(depDef);

            string tempFn = Path.Combine(Path.GetTempPath(), Path.GetFileName(dep0File));

            if (File.Exists(tempFn))
                File.Delete(tempFn);
            File.Move(dep0File, tempFn);

            string testDir = Path.Combine(Path.GetTempPath(), "lolDir");

            try
            {
                if (File.Exists("Dependency.txt"))
                    File.Delete("Dependency.txt");
                int exitCode;
                Directory.CreateDirectory(testDir);
                string output = RunPackageCli($"install --target {testDir} {Path.GetFileName(tempFn)}", out exitCode, Path.GetDirectoryName(tempFn));
                Assert.AreEqual(0, exitCode, "Unexpected exit code");
                StringAssert.Contains("Installed Pkg1", output);
                Assert.IsTrue(File.Exists(Path.Combine(testDir, "Dependency.txt")));
            }
            finally
            {
                File.Delete(dep0File);
                File.Delete(tempFn);
                Directory.Delete(testDir, true);
            }
        }

        [Test, Retry(3)]
        public void InstallFileWithDependenciesTest()
        {
            var depDef = new PackageDef();
            depDef.Name = "Dependency";
            depDef.Version = SemanticVersion.Parse("1.0");
            depDef.AddFile("Dependency.txt");
            string dep0File = DummyPackageGenerator.GeneratePackage(depDef);

            var dummyDef = new PackageDef();
            dummyDef.Name = "Dummy";
            dummyDef.Version = SemanticVersion.Parse("1.0");
            dummyDef.AddFile("Dummy.txt");
            dummyDef.Dependencies.Add(new PackageDependency( "Dependency", VersionSpecifier.Parse("1.0")));
            DummyPackageGenerator.InstallDummyPackage("Dependency"); // We need to have "Dependency" installed before we can create a package that depends on it.
            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");
                StringAssert.Contains("Dummy", output);
                StringAssert.Contains("Dependency", output);
                Assert.IsTrue(File.Exists("Dummy.txt"));
                Assert.IsTrue(File.Exists("Dependency.txt"));
            }
            finally
            {
                PluginInstaller.Uninstall(dummyDef, Directory.GetCurrentDirectory());
                PluginInstaller.Uninstall(depDef, Directory.GetCurrentDirectory());
                File.Delete(dep0File);
                File.Delete(dummyFile);
            }
        }

        [Test]
        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,MacOS";
            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");
                var output = RunPackageCli("install Dummy -y", out var exitCode);
                StringAssert.Contains("Dummy", output);
                StringAssert.Contains("Dependency", output);
                Assert.AreEqual(0, exitCode, "Unexpected exit code.\r\n" + 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);
            }
        }
        
        [Test]
        public void UninstallTest()
        {
            try
            {
                int exitCode;
                string output = RunPackageCli("install NoDepsPlugin -f -y --os Windows", out exitCode);
                Assert.AreEqual(0, exitCode, "Unexpected installation exit code");
                StringAssert.Contains("NoDepsPlugin", output);
                Assert.IsTrue(File.Exists("Packages/NoDepsPlugin/Tap.Plugins.NoDepsPlugin.dll"));

                output = RunPackageCli("uninstall NoDepsPlugin", out exitCode);
                Assert.AreEqual(0, exitCode, "Unexpected uninstallation exit code");
                StringAssert.Contains("NoDepsPlugin", output);
                Assert.IsFalse(File.Exists("Packages/NoDepsPlugin/Tap.Plugins.NoDepsPlugin.dll"));
            }
            finally
            {
                if (Directory.Exists("Packages/NoDepsPlugin/Tap.Plugins.NoDepsPlugin.dll"))
                    Directory.Delete("Packages/NoDepsPlugin/Tap.Plugins.NoDepsPlugin.dll",true);
            }
        }

        [Test]
        public void InstallNonExistentFileTest()
        {
            int exitCode;
            string output = RunPackageCli("install NonExistent.TapPackage", out exitCode);
            Assert.AreEqual((int)ExitCodes.GeneralException, exitCode, "Unexpected exit code.\n" + output);
            StringAssert.Contains("Package 'NonExistent.TapPackage' not found.", output);
        }

        [Test]
        public void UninstallFirstTest()
        {
            var dep0Def = new PackageDef();
            dep0Def.Name = "UninstallPackage";
            dep0Def.Version = SemanticVersion.Parse("0.1");
            dep0Def.AddFile("UninstallText.txt");
            dep0Def.OS = OperatingSystem.Current.Name;
            string dep0File = DummyPackageGenerator.GeneratePackage(dep0Def);

            var dep1Def = new PackageDef();
            dep1Def.Name = "UninstallPackage";
            dep1Def.Version = SemanticVersion.Parse("0.2");
            dep1Def.AddFile("SubDir/UninstallText.txt");
            dep1Def.OS = OperatingSystem.Current.Name;
            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");
        }

        [Test]
        public void UpgradeDependencyTest()
        {
            var dep0Def = new PackageDef();
            dep0Def.Name = "Dependency";
            dep0Def.Version = SemanticVersion.Parse("0.1");
            dep0Def.AddFile("Dependency0.txt");
            string dep0File = DummyPackageGenerator.GeneratePackage(dep0Def);

            var dep1Def = new PackageDef();
            dep1Def.Name = "Dependency";
            dep1Def.Version = SemanticVersion.Parse("1.0");
            dep1Def.AddFile("Dependency1.txt");
            string dep1File = DummyPackageGenerator.GeneratePackage(dep1Def);

            var dummyDef = new PackageDef();
            dummyDef.Name = "Dummy";
            dummyDef.Version = SemanticVersion.Parse("1.0");
            dummyDef.AddFile("Dummy.txt");
            dummyDef.Dependencies.Add(new PackageDependency("Dependency", VersionSpecifier.Parse("1.0")));
            DummyPackageGenerator.InstallDummyPackage("Dependency");
            string dummyFile = DummyPackageGenerator.GeneratePackage(dummyDef);
            DummyPackageGenerator.UninstallDummyPackage("Dependency");


            try
            {
                int exitCode;
                string output = RunPackageCli("install " + dep0File + " --force", out exitCode);
                Assert.AreEqual(0, exitCode, "Unexpected exit code");
                
                output = RunPackageCli("install Dummy -y -f", out exitCode);
                Assert.AreEqual(0, exitCode, "Unexpected exit code");
                //StringAssert.Contains("upgrading", output);
                Assert.IsTrue(File.Exists("Dependency1.txt"));
            }
            finally
            {
                PluginInstaller.Uninstall(dummyDef, Directory.GetCurrentDirectory());
                PluginInstaller.Uninstall(dep1Def, Directory.GetCurrentDirectory());
                File.Delete(dep0File);
                File.Delete(dep1File);
                File.Delete(dummyFile);
            }
        }

        [Test]
        public void InstallFromRepoTest()
        {
            int exitCode;
            // TODO: we need the --version part below because the release version of License Injector does not yet support OpenTAP 9.x, when it does, we can remove it again.
            string output = RunPackageCli("install \"Demonstration\" -r http://packages.opentap.io", out exitCode);
            Assert.AreEqual(0, exitCode, "Unexpected exit code: " + output);
            Assert.IsTrue(output.Contains("Installed Demonstration"));
            output = RunPackageCli("uninstall \"Demonstration\" -f", out exitCode);
            Assert.AreEqual(0, exitCode, "Unexpected exit code: " + output);
        }

        [Test]
        public void InstallFileWithMissingDependencyTest()
        {
            var def = new PackageDef();
            def.Name = "Dummy2";
            def.OS = "Windows,Linux,MacOS";
            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", out exitCode);
                Assert.AreNotEqual(0, exitCode, "Unexpected exit code");
                StringAssert.Contains("Could not install Dummy2", output);
            }
            finally
            {
                File.Delete(pkgFile);
            }
        }

        [Test]
        public void InstallPackagesFileTest()
        {
            string packageName = "REST-API", prerelease = "rc";
            var installation = new Installation(Directory.GetCurrentDirectory());
            
            int exitCode;

            string output = RunPackageCli("install -v -f \"" + packageName + "\" --version \"1.1.180-" + prerelease + "\" -y", out exitCode);
            var installedAfter = installation.GetPackages();

            if (installedAfter.Any(p => p.Name == packageName) == false)
                Console.WriteLine(output);
            
            Assert.IsTrue(installedAfter.Any(p => p.Name == packageName), "Package '" + packageName + "' was not installed.");
            Assert.IsTrue(installedAfter.Any(p => p.Name == packageName && p.Version.PreRelease == prerelease), "Package '" + packageName + "' was not installed with '--version'.");
            
            output = RunPackageCli("uninstall \"" + packageName + "\"", out exitCode);
            installedAfter = installation.GetPackages();
            Assert.IsFalse(installedAfter.Any(p => p.Name == packageName), "Package '" + packageName + "' was not uninstalled.");
        }

        [Test]
        public void NoDowngradeInstallTest()
        {
            var installation = new Installation(Directory.GetCurrentDirectory());

            var package = new PackageDef();
            package.Name = "NoDowngradeTest";
            package.Version = SemanticVersion.Parse("1.0.1");
            package.OS = OperatingSystem.Current.Name;
            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} --force", 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}  --force", out exitCode);
            Assert.IsTrue(exitCode == 0 && output.ToLower().Contains("no package(s) were upgraded"), "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} --force", 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}'.");
        }

        [Test]
        public void SkipInstallExactVersionAlreadyInstalledTest()
        {
            var package = new PackageDef();
            package.Name = "ExactVersionTest";
            package.Version = SemanticVersion.Parse("1.0.1");
            package.OS = "Windows,Linux,MacOS";
            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.");
        }


        private static string RunPackageCli(string args, out int exitCode, string workingDir = null)
        {
            return RunPackageCliWrapped(args, out exitCode, workingDir);
        }

        private static string RunPackageCliWrapped(string args, out int exitCode, string workingDir, string fileName = null)
        {
            fileName ??= Path.Combine(ExecutorClient.ExeDir, "tap");
            var p = new Process();
            p.StartInfo = new ProcessStartInfo
            {
                FileName = fileName,
                WorkingDirectory = workingDir,
                Arguments = "package " + args,
                RedirectStandardOutput = true,
                RedirectStandardError = true,
                UseShellExecute = false
            };

            StringBuilder output = new StringBuilder();
            var lockObj = new object();

            void onOutput(object s, DataReceivedEventArgs e)
            {
                if (e.Data != null)
                    lock (lockObj)
                        output.AppendLine(e.Data);
            }

            p.OutputDataReceived += onOutput;
            p.ErrorDataReceived += onOutput;

            p.Start();

            p.BeginErrorReadLine();
            p.BeginOutputReadLine();

            p.WaitForExit(125000); // TapUninstallSelfTest can hang while waiting for files to be freed up. 125 seconds ought to be enough for everyone!

            if (!p.HasExited)
            {
                p.Kill();
                exitCode = -1;
            }
            else
            {
                exitCode = p.ExitCode;
                p.WaitForExit(); // The WaitForExit(int) overload called earlier does not wait for output processing to complete, this one does.
            }
            lock (lockObj)
                return output.ToString();
        }
    }
}