[Trait("Category", "integration")] // because it talks to nuget.org
public async Task CacheGetPackageVersions()
{
InitializeClient(CacheIndex);
var findByIdRes = new RemoteV3FindPackageByIdResource(_sourceRepository, _httpSource.HttpSource);
var versions = await findByIdRes.GetAllVersionsAsync("log4net",
_cacheContext, logger, CancellationToken.None);
Assert.Contains(versions, p => p.Equals(NuGetVersion.Parse("2.0.8")));
}
[Trait("Category", "integration")] // because it talks to nuget.org
public async Task CacheGetDependencyInfo()
{
InitializeClient(CacheIndex);
var findByIdRes = new RemoteV3FindPackageByIdResource(_sourceRepository, _httpSource.HttpSource);
var info = await findByIdRes.GetDependencyInfoAsync("log4net", NuGetVersion.Parse("2.0.8"),
_cacheContext, logger, CancellationToken.None);
Assert.Equal(new PackageIdentity("log4net", NuGetVersion.Parse("2.0.8")), info.PackageIdentity);
}
[Trait("Category", "integration")] // because it talks to nuget.org
public async Task CacheDownloadValidPackage()
{
InitializeClient(CacheIndex);
var findByIdRes = new RemoteV3FindPackageByIdResource(_sourceRepository, _httpSource.HttpSource);
var downloader = await findByIdRes.GetPackageDownloaderAsync(
new PackageIdentity("log4net", NuGetVersion.Parse("2.0.8")),
_cacheContext, logger, CancellationToken.None);
string tempPath = Path.Combine(tempDir.UniqueTempFolder, "test.nupkg");
await downloader.CopyNupkgFileToAsync(tempPath, CancellationToken.None);
Assert.True(File.Exists(tempPath));
}
[Trait("Category", "integration")] // because it uses external nupkg files
public async Task Push2VersionsAndGetDependencyInfo()
{
InitializeClient(MainIndex);
var packageResource = await _sourceRepository.GetResourceAsync <PackageUpdateResource>();
await packageResource.Push(TestResources.GetNupkgBagetTwoV1(),
null, 5, false, GetApiKey, GetApiKey, false, logger);
var findByIdRes = new RemoteV3FindPackageByIdResource(_sourceRepository, _httpSource.HttpSource);
var info = await findByIdRes.GetDependencyInfoAsync("liget-two", NuGetVersion.Parse("1.0.0"),
_cacheContext, logger, CancellationToken.None);
Assert.Equal(new PackageIdentity("liget-two", NuGetVersion.Parse("1.0.0")), info.PackageIdentity);
}
private RemoteV3FindPackageByIdResourceTest(
RemoteV3FindPackageByIdResource resource,
SourceRepository sourceRepository,
FileInfo package,
PackageIdentity packageIdentity,
SourceCacheContext sourceCacheContext,
TestHttpSource httpSource,
TestDirectory testDirectory)
{
Resource = resource;
SourceRepository = sourceRepository;
Package = package;
PackageIdentity = packageIdentity;
SourceCacheContext = sourceCacheContext;
_httpSource = httpSource;
TestDirectory = testDirectory;
}
[Trait("Category", "integration")] // because it uses external nupkg files
public async Task Push2VersionsAndGetPackageVersions()
{
InitializeClient(MainIndex);
var packageResource = await _sourceRepository.GetResourceAsync <PackageUpdateResource>();
await packageResource.Push(TestResources.GetNupkgBagetTwoV1(),
null, 5, false, GetApiKey, GetApiKey, false, logger);
await packageResource.Push(TestResources.GetNupkgBagetTwoV2(),
null, 5, false, GetApiKey, GetApiKey, false, logger);
var findByIdRes = new RemoteV3FindPackageByIdResource(_sourceRepository, _httpSource.HttpSource);
var versions = await findByIdRes.GetAllVersionsAsync("liget-two",
_cacheContext, logger, CancellationToken.None);
Assert.Contains(versions, p => p.Equals(NuGetVersion.Parse("1.0.0")));
Assert.Contains(versions, p => p.Equals(NuGetVersion.Parse("2.1.0")));
}
[Trait("Category", "integration")] // because it uses external nupkg files
public async Task PushAndDownloadValidPackage()
{
InitializeClient(MainIndex);
var packageResource = await _sourceRepository.GetResourceAsync <PackageUpdateResource>();
await packageResource.Push(TestResources.GetNupkgBagetTest1(),
null, 5, false, GetApiKey, GetApiKey, false, logger);
var findByIdRes = new RemoteV3FindPackageByIdResource(_sourceRepository, _httpSource.HttpSource);
var downloader = await findByIdRes.GetPackageDownloaderAsync(
new PackageIdentity("liget-test1", NuGetVersion.Parse("1.0.0")),
_cacheContext, logger, CancellationToken.None);
string tempPath = Path.Combine(tempDir.UniqueTempFolder, "test.nupkg");
await downloader.CopyNupkgFileToAsync(tempPath, CancellationToken.None);
Assert.Equal(File.ReadAllBytes(TestResources.GetNupkgBagetTest1()), File.ReadAllBytes(tempPath));
}
public NuRepository(List <Lazy <INuGetResourceProvider> > providers, Uri repositoryUrl, Microsoft.Extensions.Logging.ILogger <NuGetClient> logger)
{
this.providers = providers;
this.repositoryUrl = repositoryUrl;
this._logger = logger;
PackageSource packageSource = new PackageSource(repositoryUrl.AbsoluteUri);
_sourceRepository = new SourceRepository(packageSource, providers);
_cacheContext = new SourceCacheContext();
var httpSource = _sourceRepository.GetResource <HttpSourceResource>();
_regResource = _sourceRepository.GetResource <RegistrationResourceV3>();
ReportAbuseResourceV3 reportAbuseResource = _sourceRepository.GetResource <ReportAbuseResourceV3>();
_metadataSearch = new PackageMetadataResourceV3(httpSource.HttpSource, _regResource, reportAbuseResource);
_versionSearch = new RemoteV3FindPackageByIdResource(_sourceRepository, httpSource.HttpSource);
this._loggerAdapter = new NuGetLoggerAdapter <NuGetClient>(logger);
}
[Trait("Category", "integration")] // because it uses external nupkg files
public async Task PushAndDownloadPackageWithNoDependencies()
{
InitializeClient(MainIndex);
var packageResource = await _sourceRepository.GetResourceAsync <PackageUpdateResource>();
await packageResource.Push(TestResources.GetNupkgExample3(),
null, 5, false, GetApiKey, GetApiKey, false, logger);
PackageMetadataResourceV3 packageMetadataRes = GetPackageMetadataResource();
var meta = await packageMetadataRes.GetMetadataAsync("example3", true, true, _cacheContext, logger, CancellationToken.None);
Assert.NotEmpty(meta);
var one = meta.First();
Assert.Equal(new PackageIdentity("example3", NuGetVersion.Parse("1.0.0")), one.Identity);
var findByIdRes = new RemoteV3FindPackageByIdResource(_sourceRepository, _httpSource.HttpSource);
var downloader = await findByIdRes.GetPackageDownloaderAsync(
new PackageIdentity("example3", NuGetVersion.Parse("1.0.0")),
_cacheContext, logger, CancellationToken.None);
string tempPath = Path.Combine(tempDir.UniqueTempFolder, "test.nupkg");
await downloader.CopyNupkgFileToAsync(tempPath, CancellationToken.None);
}
internal static RemoteV3FindPackageByIdResourceTest Create()
{
var serviceAddress = TestUtility.CreateServiceAddress();
var packageIdentity = new PackageIdentity(
id: "xunit",
version: NuGetVersion.Parse("2.2.0-beta1-build3239"));
var testDirectory = TestDirectory.Create();
var packageSource = new PackageSource(serviceAddress);
var dependencyInfoResourceProvider = new Mock <INuGetResourceProvider>();
var dependencyInfoResource = new Mock <DependencyInfoResource>();
var remoteSourceDependencyInfo = new RemoteSourceDependencyInfo(
packageIdentity,
listed: true,
dependencyGroups: Enumerable.Empty <PackageDependencyGroup>(),
contentUri: serviceAddress + "api/v2/package/xunit/2.2.0-beta1-build3239");
dependencyInfoResource.Setup(x => x.ResolvePackages(
It.Is <string>(id => id == packageIdentity.Id),
It.IsNotNull <ILogger>(),
It.IsAny <CancellationToken>()))
.ReturnsAsync(new[] { remoteSourceDependencyInfo });
dependencyInfoResourceProvider.SetupGet(x => x.Before)
.Returns(Enumerable.Empty <string>());
dependencyInfoResourceProvider.SetupGet(x => x.After)
.Returns(Enumerable.Empty <string>());
dependencyInfoResourceProvider.SetupGet(x => x.ResourceType)
.Returns(typeof(DependencyInfoResource));
dependencyInfoResourceProvider.SetupGet(x => x.Name)
.Returns("DependencyInfoResourceProvider");
dependencyInfoResourceProvider.Setup(
x => x.TryCreate(It.IsNotIn <SourceRepository>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new Tuple <bool, INuGetResource>(true, dependencyInfoResource.Object));
var sourceRepository = new SourceRepository(
packageSource,
new[] { dependencyInfoResourceProvider.Object });
var package = SimpleTestPackageUtility.CreateFullPackage(
testDirectory.Path,
packageIdentity.Id,
packageIdentity.Version.ToNormalizedString());
var packageBytes = File.ReadAllBytes(package.FullName);
var responses = new Dictionary <string, Func <HttpRequestMessage, Task <HttpResponseMessage> > >
{
{
serviceAddress,
request => Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new TestContent(string.Empty)
})
},
{
serviceAddress + $"FindPackagesById()?id='{packageIdentity.Id}'",
request => Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new TestContent(
TestUtility.GetResource(
"NuGet.Protocol.Tests.compiler.resources.XunitFindPackagesById.xml",
typeof(RemoteV3FindPackageByIdResourceTest)))
})
},
{
serviceAddress + $"FindPackagesById()?id='{packageIdentity.Id.ToUpper()}'",
request => Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new TestContent(
TestUtility.GetResource(
"NuGet.Protocol.Tests.compiler.resources.XunitFindPackagesById.xml",
typeof(RemoteV3FindPackageByIdResourceTest)))
})
},
{
serviceAddress + "api/v2/package/xunit/2.2.0-beta1-build3239",
request => Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new ByteArrayContent(packageBytes)
})
},
{
serviceAddress + $"FindPackagesById()?id='a'",
request => Task.FromResult(new HttpResponseMessage(HttpStatusCode.NoContent))
}
};
var httpSource = new TestHttpSource(packageSource, responses);
var resource = new RemoteV3FindPackageByIdResource(
sourceRepository,
httpSource);
return(new RemoteV3FindPackageByIdResourceTest(
resource,
sourceRepository,
package,
packageIdentity,
new SourceCacheContext(),
httpSource,
testDirectory));
}
// Usage nuget-mirror -package {package} -source {sourceName} -destination {destinationName} -apikey {apikey}
static async Task Main(string[] args)
{
try
{
var commandLineParser = new SimpleCommandLineParser();
commandLineParser.Parse(args);
var package = commandLineParser.Arguments["package"][0];
var sourceFeedName = commandLineParser.Arguments["source"][0];
var destinationFeedName = commandLineParser.Arguments["destination"][0];
var apiKey = commandLineParser.Arguments["apikey"][0];
// Get package sources from configs
var settings = Settings.LoadDefaultSettings(Assembly.GetEntryAssembly().Location);
var sourceRepositoryProvider = new SourceRepositoryProvider(settings, Repository.Provider.GetCoreV3());
var packageSources = sourceRepositoryProvider.PackageSourceProvider.LoadPackageSources().ToArray();
var sourcePackageSource = packageSources.Single(s => s.Name == sourceFeedName);
var destinationPackageSource = packageSources.Single(s => s.Name == destinationFeedName);
// Source feed setup
var sourceRepository = sourceRepositoryProvider.CreateRepository(sourcePackageSource, FeedType.HttpV3);
var sourceHttpSource = HttpSource.Create(sourceRepository);
var sourcePackagesFind = new RemoteV3FindPackageByIdResource(sourceRepository, sourceHttpSource);
// Destination feed setup
var destinationRepository = sourceRepositoryProvider.CreateRepository(destinationPackageSource, FeedType.HttpV3);
var destinationHttpSource = HttpSource.Create(destinationRepository);
var destinationPackages =
new RemoteV3FindPackageByIdResource(destinationRepository, destinationHttpSource);
var updateResource = await destinationRepository.GetResourceAsync <PackageUpdateResource>();
var logger = new NullLogger();
using (var sourceCacheContext = new SourceCacheContext())
using (var destinationCacheContext = new SourceCacheContext())
{
// List all versions from source
var sourcePackageVersions = (await sourcePackagesFind
.GetAllVersionsAsync(package, sourceCacheContext, logger,
CancellationToken.None))
.Select(p => p.OriginalVersion);
// List all versions from destination
var destinationPackageVersions = (await destinationPackages
.GetAllVersionsAsync(package, destinationCacheContext, logger,
CancellationToken.None))
.Select(p => p.OriginalVersion);
// See what versions are missing
var missingVersions = sourcePackageVersions
.Where(version => !destinationPackageVersions.Contains(version))
.ToArray();
// Push missing versions
var tempPath = Path.GetTempPath();
foreach (var version in missingVersions)
{
Console.WriteLine($"Mirroring {package}.{version}...");
// download
var packageDownloader = await sourcePackagesFind.GetPackageDownloaderAsync(
new PackageIdentity(package, new NuGetVersion(version)),
sourceCacheContext, logger, CancellationToken.None);
var destinationFilePath = Path.Combine(tempPath, $"OwinHttpMessageHandler.{version}.nupkg");
await packageDownloader.CopyNupkgFileToAsync(destinationFilePath, CancellationToken.None);
// push
await updateResource.Push(destinationFilePath, null, 600, false, s => apiKey, _ => null,
logger);
}
}
Console.WriteLine("Complete.");
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
