public async Task TestAllBasicScenariosForLocalShare()
{
List <PackageIdentity> packages = new List <PackageIdentity>();
packages.Add(new PackageIdentity("Nuget.core", new NuGetVersion("2.8.5")));
packages.Add(new PackageIdentity("Nuget.core", new NuGetVersion("2.5.0")));
//create a local package source by downloading the specific packages from remote feed.
SetupLocalShare(packages);
//Create source repo based on the local share.
string curDir = string.Empty;
#if !DNXCORE50
curDir = Environment.CurrentDirectory;
#endif
SourceRepository repo = GetSourceRepository(curDir);
UIMetadataResource resource = repo.GetResource <UIMetadataResource>();
Assert.True(resource != null);
//check if UIPackageMetadata works fine.
IEnumerable <UIPackageMetadata> packageMetadataList = resource.GetMetadata("Nuget.core", true, true, CancellationToken.None).Result;
Assert.True(packageMetadataList != null);
Assert.Equal(3, packageMetadataList.Count());
Assert.True(packageMetadataList.All(item => item.Tags.Contains("nuget")));
Assert.True(packageMetadataList.All(item => item.RequireLicenseAcceptance.Equals(false)));
Assert.True(packageMetadataList.All(item => item.ProjectUrl.ToString().Equals("http://nuget.codeplex.com/")));
Assert.True(packageMetadataList.Any(item => item.DependencySets.Count() == 1));
Assert.True(packageMetadataList.First(item => item.DependencySets.Count() == 1).DependencySets.First().Packages.Any(item2 => item2.Id.Equals("Microsoft.Web.Xdt", StringComparison.OrdinalIgnoreCase)));
//Check if downloadresource works fine.
DownloadResource downloadResource = repo.GetResource <DownloadResource>();
Uri downloadUrl = await downloadResource.GetDownloadUrl(new PackageIdentity("Nuget.core", new NuGetVersion("2.5.0")));
Assert.True(downloadUrl.IsFile);
Assert.True(File.Exists(downloadUrl.LocalPath)); //path doesnt contain the folder name and also the version is normalized in path for local scenario.
//Check if metadata resource works fine.
MetadataResource metadataResource = repo.GetResource <MetadataResource>();
NuGetVersion latestVersion = await metadataResource.GetLatestVersion("Nuget.core", true, false, CancellationToken.None);
Assert.True(latestVersion.ToNormalizedString().Contains("2.8.5"));
}
private async Task <NuGetPackageVersion> CacheGetVersionMeta(UIMetadataResource metaResource, PackageIdentity versionIdentity, bool showDependencies)
{
string key = String.Format(@"{0}-{1}", versionIdentity.ToString(), showDependencies);
if (base.IsInCache <NuGetPackageVersion>("GetVersionMeta", key))
{
return(Get <NuGetPackageVersion>("GetVersionMeta", key));
}
else
{
var meta = await metaResource.GetMetadata(versionIdentity, CancellationToken.None);
var output = await GetVersionMeta(versionIdentity, metaResource, showDependencies);
return(Get <NuGetPackageVersion>("GetVersionMeta", key, () => { return output; }));
}
}
private static async Task <NuGetPackageVersion> GetVersionMeta(PackageIdentity versionIdentity,
UIMetadataResource metaResource, bool getDependencies)
{
var packageVersion = new NuGetPackageVersion();
var meta = await metaResource.GetMetadata(versionIdentity, CancellationToken.None);
packageVersion.PackageID = meta.Identity.Id;
packageVersion.Description = meta.Description;
//Uri
packageVersion.IconUri = meta.IconUrl;
packageVersion.ProjectUri = meta.ProjectUrl == null ? "#" : meta.ProjectUrl.AbsoluteUri;
packageVersion.LicenseUri = meta.LicenseUrl == null ? "#" : meta.LicenseUrl.AbsoluteUri;
packageVersion.ReportAbuseUri = meta.ReportAbuseUrl.AbsoluteUri;
//TODO:Currently NuGet API return blank
packageVersion.Authors = String.Join(",", meta.Authors);
packageVersion.Owners = String.Join(",", meta.Owners);
//Supported Frameworks
packageVersion.SupportedFrameworks = new List <NuGetFrameworkInfo>();
if (getDependencies)
{
foreach (var item in meta.DependencySets)
{
if (item.TargetFramework.IsUnsupported)
{
continue;
}
NuGetFrameworkInfo fxInfo = NuGetFrameworkInfo.CreateFrom(item.TargetFramework);
var dependentOn = item.Packages.Count();
if (dependentOn > 0)
{
fxInfo.DependencyCount = dependentOn;
}
packageVersion.SupportedFrameworks.Add(fxInfo);
}
if (!packageVersion.SupportedFrameworks.Any())
{
packageVersion.SupportedFrameworks.Add(NuGetFrameworkInfo.Any());
}
}
return(packageVersion);
}
public async Task LoadPackageMetadaAsync(UIMetadataResource metadataResource, CancellationToken token)
{
var downloadCountDict = _searchResultPackage.Versions.ToDictionary(
v => v.Version,
v => v.DownloadCount);
var dict = new Dictionary <NuGetVersion, DetailedPackageMetadata>();
if (metadataResource != null)
{
// load up the full details for each version
try
{
var metadata = await metadataResource.GetMetadata(Id, true, false, token);
foreach (var item in metadata)
{
if (!dict.ContainsKey(item.Identity.Version))
{
int downloadCount;
if (!downloadCountDict.TryGetValue(item.Identity.Version, out downloadCount))
{
downloadCount = 0;
}
dict.Add(item.Identity.Version, new DetailedPackageMetadata(item, downloadCount));
}
}
}
catch (InvalidOperationException)
{
// Ignore failures.
}
}
_metadataDict = dict;
DetailedPackageMetadata p;
if (SelectedVersion != null &&
_metadataDict.TryGetValue(SelectedVersion.Version, out p))
{
PackageMetadata = p;
}
}
public async Task TestVisualStudioUIMetadataResource(string SourceUrl)
{
SourceRepository repo = GetSourceRepository(SourceUrl);
UIMetadataResource resource = repo.GetResource <UIMetadataResource>();
Assert.True(resource != null);
var result = await resource.GetMetadata("Microsoft.AspNet.Razor", true, true, CancellationToken.None);
UIPackageMetadata packageMetadata = result.FirstOrDefault(
p => p.Identity.Version == new NuGetVersion("4.0.0-beta1"));
Assert.True(packageMetadata.DependencySets.Count() == 1);
Assert.True(packageMetadata.DependencySets.First().Packages.Count().Equals(12));
IEnumerable <UIPackageMetadata> packageMetadataList = resource.GetMetadata("Nuget.core", true, true, CancellationToken.None).Result;
Assert.True(packageMetadataList != null);
Assert.Equal(47, packageMetadataList.Count());
}
public async Task TestAllResourcesForNonExistentPackage(string SourceUrl)
{
string packageId = "nonexistentpackage";
string version = "1.0";
SourceRepository repo = GetSourceRepository(SourceUrl);
DownloadResource downloadResource = await repo.GetResource <DownloadResource>();
Assert.True(downloadResource != null);
Uri downloadMetadata = await downloadResource.GetDownloadUrl(new PackageIdentity(packageId, new NuGetVersion(version)));
Assert.True(downloadMetadata == null);
MetadataResource metadataResource = await repo.GetResource <MetadataResource>();
Assert.True(metadataResource != null);
NuGetVersion latestVersion = await metadataResource.GetLatestVersion(packageId, true, true, CancellationToken.None);
Assert.True(latestVersion == null);
UIMetadataResource uiMetadataResource = await repo.GetResource <UIMetadataResource>();
Assert.True(uiMetadataResource != null);
var result = await uiMetadataResource.GetMetadata(packageId, true, true, CancellationToken.None);
Assert.False(result.Any());
DepedencyInfoResource resource = await repo.GetResource <DepedencyInfoResource>();
//Check if we are able to obtain a resource
Assert.True(resource != null);
List <PackageIdentity> packageIdentities = new List <PackageIdentity>();
packageIdentities.Add(new PackageIdentity(packageId, new NuGetVersion(version)));
IEnumerable <PackageDependencyInfo> packages = await resource.ResolvePackages(packageIdentities, NuGet.Frameworks.NuGetFramework.AnyFramework, true, new CancellationToken());
Assert.True(packages == null || packages.Count() == 0);
}
private async Task <SiteExtensionInfo> CheckRemotePackageLatestVersion(SiteExtensionInfo info, UIMetadataResource metadataResource)
{
bool isNuGetPackage = false;
if (!string.IsNullOrEmpty(info.FeedUrl))
{
isNuGetPackage = FeedExtensions.IsNuGetRepo(info.FeedUrl);
}
UIPackageMetadata localPackage = await metadataResource.GetLatestPackageByIdFromMetaRes(info.Id,
explicitTag : isNuGetPackage);
if (localPackage != null)
{
SetLocalInfo(info);
// Assume input package (from remote) is always the latest version.
info.LocalIsLatestVersion = NuGetVersion.Parse(info.Version).Equals(localPackage.Identity.Version);
}
return(info);
}
private async Task <SiteExtensionInfo> ConvertRemotePackageToSiteExtensionInfo(UIPackageMetadata package, string feedUrl, UIMetadataResource metadataResource)
{
// convert uipackagemetadata structure to siteextensioninfo structure
var siteExtensionInfo = new SiteExtensionInfo(package);
siteExtensionInfo.FeedUrl = feedUrl;
// check existing local site extension version and update the field "LocalIsLatestVersion" in siteextensioninfo
return(await CheckRemotePackageLatestVersion(siteExtensionInfo, metadataResource));
}
private async Task <SiteExtensionInfo> CheckRemotePackageLatestVersion(SiteExtensionInfo info, UIMetadataResource metadataResource)
{
UIPackageMetadata localPackage = await metadataResource.GetLatestPackageByIdFromMetaRes(info.Id);
if (localPackage != null)
{
SetLocalInfo(info);
// Assume input package (from remote) is always the latest version.
info.LocalIsLatestVersion = NuGetVersion.Parse(info.Version).Equals(localPackage.Identity.Version);
}
return(info);
}
// can be called concurrently if metaDataResource is provided
internal static async Task <UIPackageMetadata> GetLatestPackageByIdFromMetaRes(this UIMetadataResource metadataResource, string packageId, bool includePrerelease = true, bool includeUnlisted = false)
{
UIPackageMetadata latestPackage = null;
IEnumerable <UIPackageMetadata> packages = await metadataResource.GetMetadata(packageId, includePrerelease, includeUnlisted, token : CancellationToken.None);
foreach (var p in packages)
{
if (latestPackage == null ||
latestPackage.Identity.Version < p.Identity.Version)
{
latestPackage = p;
}
}
return(latestPackage);
}
// can be called concurrently if metaDataResource is provided
internal static async Task <UIPackageMetadata> GetLatestPackageByIdFromMetaRes(this UIMetadataResource metadataResource, string packageId, bool includePrerelease = true, bool includeUnlisted = false)
{
UIPackageMetadata latestPackage = null;
IEnumerable <UIPackageMetadata> packages = await metadataResource.GetMetadata(packageId, includePrerelease, includeUnlisted, token : CancellationToken.None);
foreach (var p in packages)
{
if (latestPackage == null ||
latestPackage.Identity.Version < p.Identity.Version)
{
latestPackage = p;
}
}
// If we couldn't find any listed version, fall back to looking for unlisted versions, to avoid failing completely.
// Reasoning is that if all the versions have been unlisted, it should still be possible to install it by
// explicit id, even without specifying a version
if (latestPackage == null && !includeUnlisted)
{
latestPackage = await GetLatestPackageByIdFromMetaRes(metadataResource, packageId, includePrerelease, includeUnlisted : true);
}
return(latestPackage);
}
// can be called concurrently if metaDataResource is provided
internal static async Task <UIPackageMetadata> GetLatestPackageByIdFromMetaRes(this UIMetadataResource metadataResource, string packageId, bool includePrerelease = true, bool includeUnlisted = false, bool explicitTag = false)
{
UIPackageMetadata latestPackage = null;
IEnumerable <UIPackageMetadata> packages = await metadataResource.GetMetadata(packageId, includePrerelease, includeUnlisted, token : CancellationToken.None);
// When using nuget.org, we only look at packages that have our tag.
if (explicitTag)
{
packages = packages.Where(item => item.Tags.IndexOf("azuresiteextension", StringComparison.OrdinalIgnoreCase) >= 0);
}
foreach (var p in packages)
{
if (latestPackage == null ||
latestPackage.Identity.Version < p.Identity.Version)
{
latestPackage = p;
}
}
// If we couldn't find any listed version, fall back to looking for unlisted versions, to avoid failing completely.
// Reasoning is that if all the versions have been unlisted, it should still be possible to install it by
// explicit id, even without specifying a version
if (latestPackage == null && !includeUnlisted)
{
latestPackage = await GetLatestPackageByIdFromMetaRes(metadataResource, packageId, includePrerelease, includeUnlisted : true, explicitTag : explicitTag);
}
return(latestPackage);
}
protected override void ProcessRecordCore()
{
Preprocess();
UIPackageMetadata package = null;
try
{
UIMetadataResource resource = ActiveSourceRepository.GetResource <UIMetadataResource>();
Task <IEnumerable <UIPackageMetadata> > task = resource.GetMetadata(Id, IncludePrerelease.IsPresent, false, CancellationToken.None);
var metadata = task.Result;
if (!string.IsNullOrEmpty(Version))
{
NuGetVersion nVersion = PowerShellCmdletsUtility.GetNuGetVersionFromString(Version);
metadata = metadata.Where(p => p.Identity.Version == nVersion);
}
package = metadata.Where(p => string.Equals(p.Identity.Id, Id, StringComparison.OrdinalIgnoreCase))
.OrderByDescending(v => v.Identity.Version)
.FirstOrDefault();
}
catch (Exception)
{
}
if (package != null)
{
Uri targetUrl = null;
if (License.IsPresent)
{
targetUrl = package.LicenseUrl;
}
else if (ReportAbuse.IsPresent)
{
targetUrl = package.ReportAbuseUrl;
}
else
{
targetUrl = package.ProjectUrl;
}
if (targetUrl != null)
{
OpenUrl(targetUrl);
if (PassThru.IsPresent)
{
WriteObject(targetUrl);
}
}
else
{
WriteError(String.Format(CultureInfo.CurrentCulture, Resources.Cmdlet_UrlMissing, Id + " " + Version));
}
}
else
{
// show appropriate error message depending on whether Version parameter is set.
if (string.IsNullOrEmpty(Version))
{
WriteError(String.Format(CultureInfo.CurrentCulture, Resources.Cmdlet_PackageIdNotFound, Id));
}
else
{
WriteError(String.Format(CultureInfo.CurrentCulture, Resources.Cmdlet_PackageIdAndVersionNotFound, Id, Version));
}
}
}
