isn/test/isnd.tests/UnitTestWebHost.cs

using System.Linq;
using System.Threading;
using System;
using Xunit;
using isnd.Data;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Options;
using System.Diagnostics;
using isnd.tests;
using NuGet.Protocol;
using NuGet.Configuration;
using System.Threading.Tasks;
using NuGet.Protocol.Core.Types;
using isn.abst;
using NuGet.Common;
using System.Collections.Generic;
using NuGet.Versioning;

namespace isnd.host.tests
{
    [Collection("Web server collection")]
    public class UnitTestWebHost : IClassFixture<WebServerFixture>
    {
        const string apiindex = Constants.ApiVersionPrefix + "/index";
        WebServerFixture server;
        public UnitTestWebHost(WebServerFixture server)
        {
            this.server = server;
        }

        [Fact]
        public void TestHaveTestDbContextAndMigrate()
        {
            using (var serviceScope = server.Host.Services.CreateScope())
            {
                var services = serviceScope.ServiceProvider;
                var myDependency = services.GetRequiredService<ApplicationDbContext>();
                myDependency.Database.Migrate();
            }
        }

        [Fact]
        void TestDropUser()
        {

            using (var serviceScope = server.Host.Services.CreateScope())
            {
                var services = serviceScope.ServiceProvider;
                var dbContext = services.GetRequiredService<ApplicationDbContext>();
                var tester = dbContext.Users.FirstOrDefaultAsync
                (u => u.Id == server.TestingUser.Id).Result;
                if (tester != null)
                {
                    dbContext.Users.Remove(tester);
                    dbContext.SaveChanges();
                }
            }
        }


        public void NugetInstallsTest()
        {
            using (var serviceScope = server.Host.Services.CreateScope())
            {
                var isnSettings = serviceScope.ServiceProvider.GetService<IOptions<isnd.Entities.IsndSettings>>().Value;
                string pkgSourceUrl = isnSettings.ExternalUrl + apiindex + ".json";
                ProcessStartInfo psi = new ProcessStartInfo("nuget");
                psi.ArgumentList.Add("install");
                psi.ArgumentList.Add("isn.abst");
                psi.ArgumentList.Add("-PreRelease");
                psi.ArgumentList.Add("-Source");
                psi.ArgumentList.Add(pkgSourceUrl);
                Process p = Process.Start(psi);
                p.WaitForExit();
                Assert.True(p.ExitCode == 0, "nuget install failed!");
            }
        }

        [Fact]
        public void TestRegistrationV3Resource()
        {
            using (var serviceScope = server.Host.Services.CreateScope())
            {
                var isnSettings = serviceScope.ServiceProvider.GetService<IOptions<isnd.Entities.IsndSettings>>().Value;
                string pkgSourceUrl = isnSettings.ExternalUrl + apiindex+ ".json";
                NullThrottle throttle = new NullThrottle();

                PackageSource packageSource = new PackageSource(pkgSourceUrl);
                HttpSource client = new HttpSource(packageSource, PkgSourceMessageHandler, throttle);
                NuGet.Protocol.RegistrationResourceV3 res = new NuGet.Protocol.RegistrationResourceV3(client,
                new Uri(isnSettings.ExternalUrl + Constants.ApiVersionPrefix + "/registration"));
            }
        }

        [Fact]
        public void TrueTestRegistrationV3Resource()
        {
            using (var serviceScope = server.Host.Services.CreateScope())
            {
                var isnSettings = serviceScope.ServiceProvider.GetService<IOptions<isnd.Entities.IsndSettings>>().Value;
                string pkgSourceUrl = isnSettings.ExternalUrl + apiindex+ ".json";
                var prov = new RegistrationResourceV3Provider();
                var source = new PackageSource(pkgSourceUrl);
                var repo = new SourceRepository(source, new INuGetResourceProvider[] { prov });
                prov.TryCreate(repo, CancellationToken.None);

            }
        }

        private Task<HttpHandlerResource> PkgSourceMessageHandler()
        {
            throw new NotImplementedException();
        }
        public string SPIIndexURI
        {
            get => server.Addresses.First(a => a.StartsWith("http:")) + "/v3/index.json";
        }

        [Fact]
        public async Task TestGetMetadataAsync()
        {
            ILogger logger = NullLogger.Instance;
            CancellationToken cancellationToken = CancellationToken.None;

            SourceCacheContext cache = new SourceCacheContext();
            SourceRepository repository = Repository.Factory.GetCoreV3(SPIIndexURI);
            PackageMetadataResource resource = await repository.GetResourceAsync<PackageMetadataResource>();

            IEnumerable<IPackageSearchMetadata> packages = await resource.GetMetadataAsync(
                "isn.abst",
                includePrerelease: true,
                includeUnlisted: true,
                cache,
                logger,
                cancellationToken);

            Assert.NotEmpty(packages);

            foreach (var package in packages)
            {
                Console.WriteLine($"Version: {package.Identity.Version}");
                Console.WriteLine($"Listed: {package.IsListed}");
                Console.WriteLine($"Tags: {package.Tags}");
                Console.WriteLine($"Description: {package.Description}");
            }
        }

        [Fact]
        public async Task TestFindPackageAsync()
        {
            ILogger logger = new TestLogger();
            CancellationToken cancellationToken = CancellationToken.None;
            SourceRepository repository = Repository.Factory.GetCoreV3(SPIIndexURI);
            repository.PackageSource.AllowInsecureConnections=true;
            

            PackageMetadataResource metadataResource = await repository.GetResourceAsync<PackageMetadataResource>();
            SourceCacheContext sourceCacheContext = new SourceCacheContext();
            sourceCacheContext.NoCache = true;
            sourceCacheContext.RefreshMemoryCache = true;
            
            CancellationTokenSource source = new CancellationTokenSource();
            var meta = await metadataResource.GetMetadataAsync( "isn.abst", true, false, sourceCacheContext, logger, source.Token); 
           
            foreach (IPackageSearchMetadata result in meta)
            {
                Console.WriteLine($"Found package {result.Identity.Id} {result.Identity.Version}");
            }
            Assert.NotEmpty( meta.Where(result => result.DependencySets.Any()));
        }
        
        [Fact]
        public async Task TestPackagePush()
        {
            server.EnsureUser(server.TestingUserName);
            var logger = new TestLogger();
            SourceRepository repository = Repository.Factory.GetCoreV3(SPIIndexURI);
            PackageUpdateResource pushRes = await repository.GetResourceAsync<PackageUpdateResource>();
            SymbolPackageUpdateResourceV3 symbolPackageResource = await repository.GetResourceAsync<SymbolPackageUpdateResourceV3>();
            
            await pushRes.Push(new List<string>{ "../../../../../src/isn.abst/bin/Release/isn.abst.1.0.24.nupkg" }, null,
                5000, false, GetApiKey, GetSymbolsApiKey, false, false, symbolPackageResource, logger);

        }
        
        // not yet from testing url a [Fact]
        public async Task TestGetPackageUri()
        {
            PackageSource source = new PackageSource("https://isn.pschneider.fr/v3/index.json");
            source.ProtocolVersion=3;
            SourceRepository repository = Repository.Factory.GetCoreV3(source);
            string index = repository.ToJson();
            PackageDetailsUriResourceV3 uriRes = await repository.GetResourceAsync<PackageDetailsUriResourceV3>();
            Assert.NotNull(uriRes);// package details Uri Resource
            Uri u = uriRes.GetUri("isn.abst", new NuGetVersion("1.0.24"));
        }

        private string GetSymbolsApiKey(string apiUrl)
        {
            return GetApiKey(apiUrl);
        }

        private string GetApiKey(string apiUrl)
        {
            return server.ProtectedTestingApiKey;
        }
    }

    internal class TestLogger : NuGet.Common.LoggerBase
    {
        public override void Log(ILogMessage message)
        {
            string msg = $"{message.Level}: {message.Message}";
            switch (message.Level)
            {
                case LogLevel.Debug:
                case LogLevel.Information:
                case LogLevel.Verbose:
                case LogLevel.Minimal:
                case LogLevel.Warning:
                case LogLevel.Error:
                    Debug.WriteLine(msg);
                break;
            }
        }

        public override Task LogAsync(ILogMessage message)
        {
            return Task.Run(()=>Log(message));
        }
    }
}