//            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 System;
using NUnit.Framework;
using System.IO;
using System.Collections.Generic;
using System.Linq;
using OpenTap.Authentication;

namespace OpenTap.Package.UnitTests
{
    [SetUpFixture]
    public class TapTestInit
    {
        [OneTimeSetUp]
        public static void AssemblyInit()
        {
            EngineSettings.LoadWorkingDirectory(System.IO.Path.GetDirectoryName(typeof(TestStep).Assembly.Location));
            PluginManager.SearchAsync().Wait();
            SessionLogs.Initialize(string.Format("Tap.Package.UnitTests {0}.TapLog", DateTime.Now.ToString("HH-mm-ss.fff")));
        }

        [OneTimeTearDown]
        public static void AssemblyCleanup()
        {
            SessionLogs.Flush();
        }
    }

    [TestFixture]
    public class RepositoryManagerTest
    {
        static TraceSource log =  OpenTap.Log.CreateSource("Test");
        [Test]
        public void FileRepositoryManagerTest()
        {
            var manager = new FilePackageRepository(Path.Combine(Directory.GetCurrentDirectory(), "TapPackages"));
            RepositoryManagerReceivePackageList(manager);
            TestDownload(manager);
        }

        [TestCase("file:///C:/Packages", "file:///C:/Packages", "Windows")]
        [TestCase("file:///C:/Packages/", "file:///C:/Packages/", "Windows")]
        [TestCase("file:///Packages/", "file:///{Drive}Packages/", "Windows")]
        [TestCase("file:///Packages", "file:///Packages", "Linux")]
        [TestCase("file:///Packages/", "file:///Packages/", "Linux")]
        [TestCase("C:/Packages", "file:///C:/Packages", "Windows")]
        [TestCase("C:/Packages/", "file:///C:/Packages/", "Windows")]
        [TestCase("/Packages", "file:///Packages", "Linux")]
        [TestCase("/Packages/", "file:///Packages", "Linux")]
        [TestCase("C:\\Packages/", "file:///C:/Packages/", "Windows")]
        [TestCase("PackageCache", "file:///{CurrentDirectory}/PackageCache")]
        [TestCase("PackageCache/", "file:///{CurrentDirectory}/PackageCache/")]
        [TestCase(@"\\wsl.localhost\arch\packages\", "file://wsl.localhost/arch/packages")]
        [TestCase(@"\\192.168.0.100\some\directory\", "file://192.168.0.100/some/directory")]
        public void FileRepositoryUrls(string input, string expectedUrl, string os = "Windows,Linux")
        {
            if (!os.Contains(OperatingSystem.Current.ToString()))
                return;

            // on linux current directory start with a /, but expected url already contains the extra '/'. e.g file:///.
            var cd = Directory.GetCurrentDirectory().TrimStart('/');
            expectedUrl = expectedUrl.Replace("{CurrentDirectory}", cd.Replace('\\', '/'));
            expectedUrl = expectedUrl.Replace("{Drive}", new DriveInfo(Directory.GetCurrentDirectory()).Name)
                .Replace('\\', '/');

            FilePackageRepository repository = new FilePackageRepository(input);
            Assert.AreEqual(expectedUrl, repository.Url);
        }

        [Test, Ignore("The test is slow and the endpoint is deprecated.")]
        public void HttpRepositoryManagerTest()
        {
            var manager = new HttpPackageRepository("http://packages.opentap.io/");
            RepositoryManagerReceivePackageList(manager);
            TestDownload(manager);
        }

        [Test]
        [TestCase("http://packages.opentap.io")]
        [TestCase("https://packages.opentap.io")]
        [TestCase("packages.opentap.io")]
        public void TestInstantiateHttpRepository(string repo)
        {
            // Some plugins depend on being able to instantiate http package repository without a scheme
            new HttpPackageRepository(repo);
        }

        [Test]
        public void TestUserId()
        {
            var idPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData, Environment.SpecialFolderOption.Create), "OpenTap", "OpenTapGeneratedId");
            string orgId = null;
            if (File.Exists(idPath))
                orgId = File.ReadAllText(idPath);

            try
            {
                // Check id are the same
                var id = Installation.GetMachineId();
                var id2 = Installation.GetMachineId();
                Assert.AreEqual(id, id2, "User id are different between runs.");

                // Remove id file
                File.Delete(idPath);
                if (File.Exists(idPath))
                    Assert.Fail("Id still exists.");
                Assert.AreNotEqual(Installation.GetMachineId(), default(Guid), "Failed to create new user id after deleting file.");
                Assert.IsTrue(Guid.TryParse(Installation.GetMachineId(), out Guid _));

                // Remove directory
                Directory.Delete(Path.GetDirectoryName(idPath), true);
                Assert.AreNotEqual(Installation.GetMachineId(), default(Guid), "Failed to create new user id after deleting directory.");
                Assert.IsTrue(Guid.TryParse(Installation.GetMachineId(), out Guid _));

                // Tamper with id file
                File.WriteAllText(idPath, "Not a valid GUID");
                Assert.AreNotEqual(Installation.GetMachineId(), default(Guid), "Failed to create new user id after tampering with file.");
                Assert.IsTrue(Guid.TryParse(Installation.GetMachineId(), out Guid _));

                Assert.AreEqual(Installation.Current.Id, Installation.Current.Id, "Installation ID gave different results!");
            }
            finally
            {
                // Revert changes
                if (orgId != null)
                    File.WriteAllText(idPath, orgId);
            }
        }

        public static void RepositoryManagerReceivePackageList(IPackageRepository manager)
        {
            var tap = new PackageIdentifier("OpenTAP", SemanticVersion.Parse("7.4"), CpuArchitecture.Unspecified, "Windows");

            // ReceivePackageList.
            var allPackages = manager.GetPackages(new PackageSpecifier(os: "Windows"), tap);
            Assert.IsTrue(allPackages.Length > 0, "args(7.4)");

            #region GetPackages
            log.Info("GetPackages - STARTED");

            // Get packages running in developer mode.
            tap.Version = SemanticVersion.Parse("7.3.0-Development");
            var bag = manager.GetPackages(new PackageSpecifier(os: "Windows"), tap);
            Assert.IsTrue(bag.Length > 0, "args(7.3 Development)");
            log.Info("args(7.3 Development) - SUCCESS");

            // Get packages running in release mode without build version.
            tap.Version = PluginManager.GetOpenTapAssembly().SemanticVersion;
            bag = manager.GetPackages(new PackageSpecifier(os: "Windows"), tap);
            Assert.IsTrue(bag.Length > 0, "args(TapEngine)");
            log.Info("args(TapEngine) - SUCCESS");

            log.Info("GetPackages - COMPLETED");
            #endregion
        }

        public static void TestDownload(IPackageRepository manager)
        {
            var tap = new PackageIdentifier("OpenTAP", SemanticVersion.Parse("7.5.0-Development"), CpuArchitecture.Unspecified, "Windows");

            // Download package.
            var bag = manager.GetPackages(new PackageSpecifier(os: "Windows"), tap);
            Assert.IsTrue(bag.Length > 0, "args(7.5.0-Development)");
            var package = bag[0];
            var path = Path.Combine(Directory.GetCurrentDirectory(), package.Name + ".TapPackage");
            manager.DownloadPackage(package, path, new System.Threading.CancellationToken());
            Assert.IsTrue(File.Exists(path));
            log.Info("DownloadPackage - args() - SUCCESS");

            if (manager is FilePackageRepository)
            {
                // Download to same folder.
                manager.DownloadPackage(package, path, new System.Threading.CancellationToken());
                Assert.IsTrue(File.Exists((package.PackageSource as FileRepositoryPackageDefSource)?.PackageFilePath));
                log.Info("DownloadPackage - args(Same folder) - SUCCESS");
                (manager as FilePackageRepository).Reset();
            }

            // Download when file already exists.
            tap.Version = PluginManager.GetOpenTapAssembly().SemanticVersion;
            bag = manager.GetPackages(new PackageSpecifier(os: "Windows"), tap);
            Assert.IsTrue(bag.Length > 0, "args(TapEngine)");
            package = bag.ToArray()[0];
            manager.DownloadPackage(package, path, new System.Threading.CancellationToken());
            File.Delete(path);
        }
    }


    [TestFixture]
    public class RepositoryManagerTests
    {
        static TraceSource log =OpenTap.Log.CreateSource("Test");
        [Test]
        public void RepositoryManagerLoadAllPackagesTest()
        {
            log.Info("-----------------------------RepositoryManager LoadAllPackages-----------------------------");
            var tempFolder = "RepositoryManagerTestTempFolder";

            try
            {
                // Empty folder.
                Directory.CreateDirectory(tempFolder);
                var repo = new FilePackageRepository(tempFolder);
                Assert.IsTrue(repo.GetPackages(new PackageSpecifier()).Any() == false, "Empty");
                log.Info("Empty folder - SUCCESS");

                // Folder with one plugin.
                Directory.CreateDirectory("TapPackage");
                File.Copy("TapPackages/MyPlugin1.TapPackage", tempFolder + "/MyPlugin1.TapPackage",true);
                repo.Reset();
                Assert.IsTrue(repo.GetPackages(new PackageSpecifier(os: "Windows")).Count() == 1, "Folder with one package");
                log.Info("Folder with one plugin - SUCCESS");

                // Folder with several plugins.
                Directory.GetFiles("TapPackages").ToList().ForEach(f => File.Copy(f, Path.Combine(tempFolder, Path.GetFileName(f)), true));
                repo.Reset();
                var anyVersion = new PackageSpecifier(os: "Windows");
                Assert.AreEqual(9, repo.GetPackages(anyVersion).Count(), "Folder with several packages");
                log.Info("Folder with several plugin - SUCCESS");
            }
            finally
            {
                if (Directory.Exists(tempFolder))
                    Directory.Delete(tempFolder, true);
            }
        }
    }

    [TestFixture]
    public class DependencyAnalyzerTests
    {
        static TraceSource log =OpenTap.Log.CreateSource("Test");
        [Test]
        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");
        }

        [Test]
        public void DependencyAnalyzerFilterRelatedTest()
        {
            log.Info("-----------------------------DependencyAnalyzer FilterRelated-----------------------------");

            // Test setup.
            var tapPackage = new PackageDef() { Name = "Tap", Version = SemanticVersion.Parse("9.0") };// TapVersion.GetTapEngineVersion().ToString() };
            var packages = new List<PackageDef>();
            packages.Add(tapPackage);
            using (var xmlText = File.OpenRead(Path.Combine(Directory.GetCurrentDirectory(), "TapPackages/MyPlugin3.xml")))
                packages.AddRange(PackageDef.ManyFromXml(xmlText));
            using (var xmlText = File.OpenRead(Path.Combine(Directory.GetCurrentDirectory(), "TapPackages/MyPlugin2.xml")))
                packages.AddRange(PackageDef.ManyFromXml(xmlText));
            using (var xmlText = File.OpenRead(Path.Combine(Directory.GetCurrentDirectory(), "TapPackages/MyPlugin1.xml")))
                packages.AddRange(PackageDef.ManyFromXml(xmlText));

            // No dependencies
            var dependencyAnalyzer = DependencyAnalyzer.BuildAnalyzerContext(packages.Take(2).ToList());
            var issues = dependencyAnalyzer.FilterRelated(packages.Take(2).ToList());
            Assert.IsTrue(issues.BrokenPackages.Count == 0, "No dependencies");
            log.Info("No dependencies - SUCCESS");

            // Tap dependency
            dependencyAnalyzer = DependencyAnalyzer.BuildAnalyzerContext(packages.Take(3).ToList());
            issues = dependencyAnalyzer.FilterRelated(packages.Take(3).ToList());
            Assert.IsTrue(issues.BrokenPackages.Count == 1, "Tap dependency");
            log.Info("Tap dependency - SUCCESS");

            // Several Tap dependencies
            dependencyAnalyzer = DependencyAnalyzer.BuildAnalyzerContext(packages.ToList());
            issues = dependencyAnalyzer.FilterRelated(packages.ToList());
            Assert.IsTrue(issues.BrokenPackages.Count == 2, "Several Tap dependencies");
            log.Info("Several Tap dependencies - SUCCESS");
        }

        [Test]
        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");
        }
    }

    [TestFixture]
    public class DependencyCheckerTests
    {
        static TraceSource log =  OpenTap.Log.CreateSource("Test");

        [Test]
        public void DependencyCheckerCheckDependenciesTest()
        {
            log.Info("-----------------------------DependencyChecker CheckDependencies-----------------------------");

            // Test setup
            string MyPlugin1 = Path.Combine(Directory.GetCurrentDirectory(), "TapPackages/MyPlugin1.TapPackage");
            string MyPlugin2 = Path.Combine(Directory.GetCurrentDirectory(), "TapPackages/MyPlugin2.1.2.37-alpha.715+164e6f81.TapPackage");
            string MyPlugin3 = Path.Combine(Directory.GetCurrentDirectory(), "TapPackages/MyPlugin3.TapPackage");

            // No dependencies
            EventTraceListener listener = new EventTraceListener();
            string errors = "";
            listener.MessageLogged += events => errors += Environment.NewLine + String.Join(Environment.NewLine, events.Select(m => m.Message));
            Log.AddListener(listener);
            Installation installation = new Installation(Directory.GetCurrentDirectory());
            var issues = DependencyChecker.CheckDependencies(installation, new string[] { MyPlugin1, MyPlugin2 });
            Log.RemoveListener(listener);
            Assert.IsTrue(issues == DependencyChecker.Issue.None, errors);
            log.Info("No dependencies - SUCCESS");

            // Dependency on plugin
            issues = DependencyChecker.CheckDependencies(installation, new string[] { MyPlugin1, MyPlugin2, MyPlugin3 });
            Assert.IsTrue(issues == DependencyChecker.Issue.BrokenPackages, "Dependency on plugin");
            log.Info("Dependency on plugin - SUCCESS");
        }

        [Test]
        public void TestDependencyPatchVersion()
        {
            // Verify that the resolver bumps from installed "9.12.0" because "^9.12.1" is required
            var repo = "http://packages.opentap.io";

            var installedOpenTap = new PackageDef() {Version = SemanticVersion.Parse("9.12.0"), Name = "OpenTAP", Architecture = CpuArchitecture.x64 };

            var toInstall = new PackageDef()
            {
                Name = "MockPackage",
                Dependencies = new List<PackageDependency>()
                    {new PackageDependency("OpenTAP", VersionSpecifier.Parse("^9.12.1"), "^9.12.1")},
                Architecture = CpuArchitecture.x64
            };

            var installedPackages = new Dictionary<string, PackageDef> {{"OpenTAP", installedOpenTap}};
            var packages = new[] {toInstall};
            var repositories = new List<IPackageRepository>() {new HttpPackageRepository(repo)};

            //var resolver = new DependencyResolver(installedPackages, packages, repositories);
            //
            //Assert.AreEqual(2, resolver.MissingDependencies.Count);
            //var missing = resolver.MissingDependencies.FirstOrDefault(p => p.Name == "OpenTAP");
            //
            //Assert.AreEqual("OpenTAP", missing.Name);
            //Assert.AreEqual(9, missing.Version.Major);
            //Assert.AreEqual(12, missing.Version.Minor);
            //Assert.AreEqual(1, missing.Version.Patch);
        }

        [Test]
        public void TestDependencyNoUpgrade()
        {
            // Verify that the resolver does not try to upgrade installed "9.12.0"
            var repo = "https://packages.opentap.io";

            var installedOpenTap = new PackageDef() { Version = SemanticVersion.Parse("9.12.0"), Name = "OpenTAP" };

            var toInstall = new PackageDef()
            {
                Name = "MockPackage",
                Dependencies = new List<PackageDependency>()
                    {new PackageDependency("OpenTAP", VersionSpecifier.Parse("^9.12"), "^9.12")}
            };

            var installedPackages = new Dictionary<string, PackageDef> {{"OpenTAP", installedOpenTap}};
            var packages = new[] {toInstall};
            var repositories = new List<IPackageRepository>() {new HttpPackageRepository(repo)};

            //var resolver = new DependencyResolver(installedPackages, packages, repositories);
            //Assert.AreEqual(1, resolver.MissingDependencies.Count);
            //Assert.AreEqual("MockPackage", resolver.MissingDependencies[0].Name);
        }
    }

    [TestFixture]
    public class PackageManagerTests
    {
        static TraceSource log = Log.CreateSource("Test");
        [Test]
        public void PackageManagerTestsExecution()
        {
            if(Directory.Exists("DownloadedPackages"))
                Directory.Delete("DownloadedPackages", true);

            // Test execution
            var tap = new PackageIdentifier("OpenTAP", SemanticVersion.Parse("9.0.0-Development"), CpuArchitecture.Unspecified, "Windows");

            // Development, don't check build version
            var packages = get(tap);
            // MyPlugin1 requires OpenTAP ^9.0.605 which is not compatible with 9.0.0 
            Assert.IsFalse(packages.Any(p => p.Name == "MyPlugin1"));
            Assert.IsTrue(packages.Any(p => p.Name == "MyPlugin2"));
            Assert.IsTrue(packages.Any(p => p.Name == "MyPlugin3"));

            // Release, TAP is incompatible
            tap.Version = SemanticVersion.Parse("8.0.0");
            packages = get(tap);
            Assert.IsFalse(packages.Any(p => p.Name == "MyPlugin1"));
            Assert.IsFalse(packages.Any(p => p.Name == "MyPlugin2"));
            Assert.IsTrue(packages.Any(p => p.Name == "MyPlugin3"), "GetPackages - Release, TAP is incompatible");

            // Release, OpenTAP is compatible
            tap.Version = SemanticVersion.Parse("9.0.800");
            packages = get(tap);
            Assert.IsTrue(packages.Any(p => p.Name == "MyPlugin1"));
            Assert.IsTrue(packages.Any(p => p.Name == "MyPlugin2"));
            Assert.IsTrue(packages.Any(p => p.Name == "MyPlugin3"));

            // Release, same build
            tap.Version = SemanticVersion.Parse("9.0.605");
            packages = get(tap);
            Assert.IsTrue(packages.Any(p => p.Name == "MyPlugin1"));
            Assert.IsTrue(packages.Any(p => p.Name == "MyPlugin2"));
            Assert.IsTrue(packages.Any(p => p.Name == "MyPlugin3"));

            // Release, 1 build behind
            tap.Version = SemanticVersion.Parse("9.0.604");
            packages = get(tap);
            // MyPlugin1 requires patch 605
            Assert.IsFalse(packages.Any(p => p.Name == "MyPlugin1"));
            Assert.IsTrue(packages.Any(p => p.Name == "MyPlugin2"));
            Assert.IsTrue(packages.Any(p => p.Name == "MyPlugin3"), "GetPackages - Release, 1 build behind");

            // No build
            tap.Version = new SemanticVersion(0,0,0,null,null);
            packages = get(tap);
            Assert.IsFalse(packages.Any(p => p.Name == "MyPlugin1"));
            Assert.IsFalse(packages.Any(p => p.Name == "MyPlugin2"));
            Assert.IsTrue(packages.Any(p => p.Name == "MyPlugin3"), "GetPackages - No build");
        }

        List<PackageDef> get(IPackageIdentifier compatibleWith)
        {
            var packages = PackageRepositoryHelpers.GetPackagesFromAllRepos(
                PackageManagerSettings.Current.Repositories.Where(p => p.IsEnabled).Select(s => s.Manager).Where(p => p is FilePackageRepository).ToList(),
                new PackageSpecifier(os: "Windows"), compatibleWith);

            return packages;
        }

        [TestCase("", "http://packages.opentap.io", typeof(HttpPackageRepository))]  // Http scheme
        [TestCase("", "https://packages.opentap.io", typeof(HttpPackageRepository))] // Https scheme
        [TestCase("", "ftp://packages.opentap.io", typeof(NotSupportedException))]   // Unsupported scheme
        [TestCase("", "something illegal|", typeof(NotSupportedException))]          // Illegal chars
        [TestCase("", "C:/a", typeof(FilePackageRepository))]                        // Windows absolute path
        [TestCase("", "/a/b", typeof(FilePackageRepository))]                        // Linux absolute path
        [TestCase("", "a/b", typeof(FilePackageRepository))]                         // Relative path
        [TestCase("", @"a\b", typeof(FilePackageRepository))]                        // Relative file path using backslash
        [TestCase("", "file:///./a", typeof(FilePackageRepository))]                 // Explicit file scheme
        [TestCase("", "file:///a", typeof(FilePackageRepository))]                   // Explicit file scheme
        [TestCase("", "file:///C:/a", typeof(FilePackageRepository))]                // Explicit absolute File Path
        [TestCase("", @"\\a\b", typeof(FilePackageRepository))]                      // UNC path
        [TestCase("", "packages.opentap.io", typeof(HttpPackageRepository))]         // No scheme, top level domain
        [TestCase("", "my-repo.com", typeof(HttpPackageRepository))]                 // No scheme, top level domain
        [TestCase("", ".my.file.repo.", typeof(FilePackageRepository))]              // File path with periods
        [TestCase("", "test", typeof(FilePackageRepository))]              // Relative path without directory
        [TestCase("", "./test", typeof(FilePackageRepository))]              // Relative path with current directory
        [TestCase("", "./", typeof(FilePackageRepository))]              // Current directory
        [TestCase("", ".", typeof(FilePackageRepository))]              // Current directory (single dot)
        [TestCase("http://opentap.io", "http://packages.opentap.io", typeof(HttpPackageRepository))]  // Http scheme
        [TestCase("http://opentap.io", "https://packages.opentap.io", typeof(HttpPackageRepository))] // Https scheme
        [TestCase("http://opentap.io", "packages.opentap.io", typeof(HttpPackageRepository))]         // No scheme
        [TestCase("http://opentap.io", "C:/a", typeof(FilePackageRepository))]                        // Windows absolute path
        [TestCase("http://opentap.io", "/a/b", typeof(HttpPackageRepository))]                        // Linux absolute path
        [TestCase("http://opentap.io", "a/b", typeof(HttpPackageRepository))]                         // Relative path
        [TestCase("http://opentap.io", @"a\b", typeof(HttpPackageRepository))]                        // Relative file path using backslash
        [TestCase("http://opentap.io", "file:///./a", typeof(FilePackageRepository))]                 // Explicit file scheme
        [TestCase("http://opentap.io", "file:///a", typeof(FilePackageRepository))]                   // Explicit file scheme
        [TestCase("http://opentap.io", "file:///C:/a", typeof(FilePackageRepository))]                // Explicit absolute File Path
        [TestCase("http://opentap.io", @"\\a\b", typeof(FilePackageRepository))]                      // UNC path
        //[TestCase("http://opentap.io", @"//a/b", typeof(FilePackageRepository))]                      // UNC path using forward slash (but also scheme relative URL)
        public void TestRepositoryType(string baseUrl, string url, Type expectedRepositoryType)
        {
            AuthenticationSettings.Current.BaseAddress = baseUrl;
            try
            {
                var result = PackageRepositoryHelpers.DetermineRepositoryType(url);
                if (expectedRepositoryType.DescendsTo(typeof(Exception)))
                    Assert.Fail($"Should have thrown {expectedRepositoryType.ToString()} but returned {result.GetType()}");
                Assert.AreEqual(expectedRepositoryType, result.GetType());
            }
            catch (Exception ex)
            {
                if (expectedRepositoryType == ex.GetType())
                    return;
                throw;
            }
        }


        [TestCase("http://localhost", "/api/results", "http://localhost/api/results")]
        [TestCase("http://localhost", "http://opentap.io/api/results", "http://opentap.io/api/results")]
        [TestCase("http://localhost", "https://opentap.io/api/results", "https://opentap.io/api/results")]
        [TestCase("http://localhost/hey", "/api/results", "http://localhost/api/results")]
        [TestCase("http://localhost/hey/", "api/results", "http://localhost/hey/api/results")]
        public void TestGetClient(string baseAddress, string getClientAddress, string resultingBaseAddress)
        {
            AuthenticationSettings.Current.BaseAddress = baseAddress;
            var httpClient = AuthenticationSettings.Current.GetClient(baseAddress: getClientAddress);
            Assert.AreEqual(resultingBaseAddress, httpClient.BaseAddress.ToString());
        }

        [Test]
        [Ignore("For manual debugging")]
        public void TestIfHttpPackageRepositorySupportsRelativePaths()
        {
            AuthenticationSettings.Current.BaseAddress = null;
            HttpPackageRepository httpPackageRepository = new HttpPackageRepository("packages.opentap.io");
            var packages = httpPackageRepository.GetPackageNames();
            Assert.AreEqual($"http://packages.opentap.io", httpPackageRepository.Url); // Url was changed to valid url
            Assert.IsTrue(packages.Any());
            var versions = httpPackageRepository.GetPackageVersions(packages.FirstOrDefault());
            Assert.IsTrue(versions.Any());
            string query = "query Query {packages(class:\"package\", version:\"any\"){ name version description dependencies{ name version} }}";
#pragma warning disable CS0618 // Type or member is obsolete
            var resp = httpPackageRepository.QueryGraphQL(query);
#pragma warning restore CS0618 // Type or member is obsolete
            Assert.IsNotNull(resp);
            string file = "C:/Temp/Test.TapPackage";
            try
            {
                var p = versions.FirstOrDefault();
                httpPackageRepository.DownloadPackage(new PackageIdentifier(p.Name, p.Version, p.Architecture, p.OS), file);
                Assert.IsTrue(File.Exists(file));
            }
            finally
            {
                if (File.Exists(file))
                    File.Delete(file);
            }
        }

        [Test]
        [Ignore("For manual debugging")]
        public void TestIfHttpPackageRepositorySupportsRelativePaths2()
        {
            AuthenticationSettings.Current.BaseAddress = null;
            HttpPackageRepository httpPackageRepository = new HttpPackageRepository("packages.opentap.io");
            string file = "C:/Temp/Test.TapPackage";
            try
            {
                httpPackageRepository.DownloadPackage(new PackageIdentifier("OpenTAP", "9.18.4", CpuArchitecture.x64, "Linux,MacOS"), file);
                Assert.IsTrue(File.Exists(file));
            }
            finally
            {
                if (File.Exists(file))
                    File.Delete(file);
            }
        }
    }
}