/// <summary>
/// Project.json based project system.
/// </summary>
/// <param name="jsonConfig">Path to project.json.</param>
/// <param name="msBuildProjectPath">Path to the msbuild project file.</param>
public ProjectJsonBuildIntegratedNuGetProject(
string jsonConfig,
string msBuildProjectPath)
{
if (jsonConfig == null)
{
throw new ArgumentNullException(nameof(jsonConfig));
}
if (msBuildProjectPath == null)
{
throw new ArgumentNullException(nameof(msBuildProjectPath));
}
_jsonConfig = new FileInfo(jsonConfig);
MSBuildProjectPath = msBuildProjectPath;
_projectName = Path.GetFileNameWithoutExtension(msBuildProjectPath);
if (string.IsNullOrEmpty(_projectName))
{
throw new ArgumentException(
string.Format(CultureInfo.CurrentCulture, Strings.InvalidProjectName, MSBuildProjectPath));
}
JObject projectJson;
IEnumerable <NuGetFramework> targetFrameworks = Enumerable.Empty <NuGetFramework>();
try
{
projectJson = GetJson();
targetFrameworks = JsonConfigUtility.GetFrameworks(projectJson);
}
catch (InvalidOperationException)
{
// Ignore a bad project.json when constructing the project, and treat it as unsupported.
}
// Default to unsupported if anything unexpected is returned
var targetFramework = NuGetFramework.UnsupportedFramework;
// Having more than one framework is not supported, but we pick the first as fallback
// We will eventually support more than one framework ala projectK.
if (targetFrameworks.Count() == 1)
{
targetFramework = targetFrameworks.First();
}
InternalMetadata.Add(NuGetProjectMetadataKeys.TargetFramework, targetFramework);
InternalMetadata.Add(NuGetProjectMetadataKeys.Name, _projectName);
InternalMetadata.Add(NuGetProjectMetadataKeys.FullPath, msBuildProjectPath);
var supported = new List <FrameworkName>
{
new FrameworkName(targetFramework.DotNetFrameworkName)
};
InternalMetadata.Add(NuGetProjectMetadataKeys.SupportedFrameworks, supported);
}
public override async Task <bool> InstallPackageAsync(
PackageIdentity packageIdentity,
DownloadResourceResult downloadResourceResult,
INuGetProjectContext nuGetProjectContext,
CancellationToken token)
{
var dependency = new PackageDependency(packageIdentity.Id, new VersionRange(packageIdentity.Version));
var json = await GetJsonAsync();
JsonConfigUtility.AddDependency(json, dependency);
await SaveJsonAsync(json);
var packageReader = downloadResourceResult.PackageReader
?? new PackageArchiveReader(downloadResourceResult.PackageStream, leaveStreamOpen: true);
IAsyncPackageContentReader packageContentReader = packageReader;
IAsyncPackageCoreReader packageCoreReader = packageReader;
var libItemGroups = await packageContentReader.GetLibItemsAsync(token);
var referenceItemGroups = await packageContentReader.GetReferenceItemsAsync(token);
var frameworkReferenceGroups = await packageContentReader.GetFrameworkItemsAsync(token);
var contentFileGroups = await packageContentReader.GetContentItemsAsync(token);
var buildFileGroups = await packageContentReader.GetBuildItemsAsync(token);
var toolItemGroups = await packageContentReader.GetToolItemsAsync(token);
var depsGroups = await packageContentReader.GetPackageDependenciesAsync(token);
IEnumerable <FrameworkSpecificGroup> refItemGroups = null;
if (packageReader is PackageArchiveReader reader)
{
refItemGroups = await reader.GetItemsAsync(PackagingConstants.Folders.Ref, token);
}
else if (packageReader is PackageFolderReader reader2)
{
refItemGroups = await reader2.GetItemsAsync(PackagingConstants.Folders.Ref, token);
}
var deps = (PackageDependencyInfo)NuGetProjectActions.First(x => x.PackageIdentity.Equals(packageIdentity)).PackageIdentity;
var entry = new WorkspaceEntry(packageIdentity, GetSha(downloadResourceResult.PackageStream),
depsGroups, libItemGroups, toolItemGroups, refItemGroups, _mainFile);
if (!SdkList.Dlls.Contains(entry.PackageIdentity.Id.ToLower()))
{
var workspace = await GetWorkspaceAsync();
var updater = new WorkspaceWriter();
var updated = updater.AddEntry(workspace, entry);
await SaveWorkspaceAsync(updated);
}
return(await base.InstallPackageAsync(packageIdentity, downloadResourceResult, nuGetProjectContext, token));
}
public void JsonConfigUtility_AddDependencyToNewFile()
{
// Arrange
var json = BasicConfig;
// Act
JsonConfigUtility.AddDependency(json, new PackageDependency("testpackage", VersionRange.Parse("1.0.0")));
// Assert
Assert.Equal("1.0.0", json["dependencies"]["testpackage"].ToString());
}
public void JsonConfigUtility_GetTargetFramework()
{
// Arrange
var json = BasicConfig;
// Act
var frameworks = JsonConfigUtility.GetFrameworks(json);
// Assert
Assert.Equal("netcore50", frameworks.Single().GetShortFolderName());
}
public async Task <bool> AddDependency(PackageDependency dependency,
CancellationToken token)
{
var json = await GetJsonAsync();
JsonConfigUtility.AddDependency(json, dependency);
await SaveJsonAsync(json);
return(true);
}
public async Task <bool> RemoveDependency(string packageId,
INuGetProjectContext nuGetProjectContext,
CancellationToken token)
{
var json = await GetJsonAsync();
JsonConfigUtility.RemoveDependency(json, packageId);
await SaveJsonAsync(json);
return(true);
}
public static PackageReference CreatePackageReferenceWithProjectJsonWildcardVersion(
string package,
string version)
{
string json = "{ \"dependencies\": { \"" + package + "\": \"" + version + "\" } }";
var jsonObject = JObject.Parse(json);
var dependency = JsonConfigUtility.GetDependencies(jsonObject).First();
var identity = new PackageIdentity(dependency.Id, dependency.VersionRange.MinVersion);
return(new PackageReference(identity, null, true, false, false, dependency.VersionRange));
}
public override bool Execute()
{
var fullPath = ProjectJsonPath.GetMetadata("FullPath");
using (var reader = new StreamReader(fullPath))
{
var json = JObject.Parse(reader.ReadToEnd());
PackageReferences = JsonConfigUtility.GetDependencies(json)
.Select(ConvertToTaskItem)
.ToArray();
}
return(true);
}
private void UpdateFramework(JObject json)
{
var frameworks = JsonConfigUtility.GetFrameworks(json);
if (InternalMetadata.TryGetValue(NuGetProjectMetadataKeys.TargetFramework, out object newTargetFramework))
{
if (IsUAPFramework(newTargetFramework as NuGetFramework) && frameworks.Count() == 1)
{
// project.json can have only one target framework
JsonConfigUtility.ClearFrameworks(json);
JsonConfigUtility.AddFramework(json, newTargetFramework as NuGetFramework);
}
}
}
public void JsonConfigUtility_RemoveDependencyFromNewFile()
{
// Arrange
var json = BasicConfig;
// Act
JsonConfigUtility.RemoveDependency(json, "testpackage");
JToken val = null;
json.TryGetValue("dependencies", out val);
// Assert
Assert.Null(val);
}
public void JsonConfigUtility_AddFramework()
{
// Arrange
var json = BasicConfig;
var frameworks = JsonConfigUtility.GetFrameworks(json);
Assert.Equal(1, frameworks.Count());
// Act
JsonConfigUtility.AddFramework(json, new NuGet.Frameworks.NuGetFramework("uap", new Version("10.0.0")));
frameworks = JsonConfigUtility.GetFrameworks(json);
//Assert
Assert.Equal(2, frameworks.Count());
}
public void JsonConfigUtility_ClearFrameworks()
{
// Arrange
var json = BasicConfig;
var frameworks = JsonConfigUtility.GetFrameworks(json);
Assert.Equal("netcore50", frameworks.Single().GetShortFolderName());
// Act
JsonConfigUtility.ClearFrameworks(json);
frameworks = JsonConfigUtility.GetFrameworks(json);
//Assert
Assert.Equal(0, frameworks.Count());
}
public async override Task <bool> InstallPackageAsync(
string packageId,
VersionRange range,
INuGetProjectContext nuGetProjectContext,
BuildIntegratedInstallationContext installationContext,
CancellationToken token)
{
var dependency = new PackageDependency(packageId, range);
var json = await GetJsonAsync();
JsonConfigUtility.AddDependency(json, dependency);
await SaveJsonAsync(json);
return(true);
}
public void GetDependencies_ThrowsIfObjectDoesNotHaveVersionProperty()
{
// Arrange
var json = JObject.Parse(
@"
{
""dependencies"": {
""PackageA"": { ""type"": ""build"" }
}
}");
// Act and Assert
var ex = Assert.Throws <FormatException>(() => JsonConfigUtility.GetDependencies(json).ToList());
// Assert
Assert.Equal($"Dependency '{json["dependencies"].First}' has invalid version specification.", ex.Message);
}
public void GetDependencies_ThrowsIfVersionIsAnEmptyString()
{
// Arrange
var json = JObject.Parse(
@"
{
""dependencies"": {
""PackageA"": """"
}
}");
// Act and Assert
var ex = Assert.Throws <FormatException>(() => JsonConfigUtility.GetDependencies(json).ToList());
// Assert
Assert.Equal("Dependency '\"PackageA\": \"\"' has invalid version specification.", ex.Message);
}
private async Task UpdateFrameworkAsync(JObject json)
{
// Update the internal target framework with TPMinV from csproj
await UpdateInternalTargetFrameworkAsync();
if (TryGetInternalFramework(out object newTargetFrameworkObject))
{
var frameworks = JsonConfigUtility.GetFrameworks(json);
var newTargetFramework = newTargetFrameworkObject as NuGetFramework;
if (IsUAPFramework(newTargetFramework) &&
frameworks.Count() == 1 &&
frameworks.Single() != newTargetFramework)
{
// project.json can have only one target framework
JsonConfigUtility.ClearFrameworks(json);
JsonConfigUtility.AddFramework(json, newTargetFramework as NuGetFramework);
}
}
}
public override async Task <bool> UninstallPackageAsync(
PackageIdentity packageIdentity,
INuGetProjectContext nuGetProjectContext,
CancellationToken token)
{
var json = await GetJsonAsync();
JsonConfigUtility.RemoveDependency(json, packageIdentity.Id);
await SaveJsonAsync(json);
var workspace = await GetWorkspaceAsync();
var updater = new WorkspaceWriter();
var updated = updater.RemoveEntry(workspace, packageIdentity.Id);
await SaveWorkspaceAsync(updated);
return(await base.UninstallPackageAsync(packageIdentity, nuGetProjectContext, token));
}
public override async Task <IEnumerable <PackageReference> > GetInstalledPackagesAsync(CancellationToken token)
{
var packages = new List <PackageReference>();
// Find all dependencies and convert them into packages.config style references
foreach (var dependency in JsonConfigUtility.GetDependencies(await GetJsonAsync()))
{
// Use the minimum version of the range for the identity
var identity = new PackageIdentity(dependency.Id, dependency.VersionRange.MinVersion);
// Pass the actual version range as the allowed range
packages.Add(new PackageReference(identity,
targetFramework: null,
userInstalled: true,
developmentDependency: false,
requireReinstallation: false,
allowedVersions: dependency.VersionRange));
}
return(packages);
}
public OneDasPackageManager(IExtensionFactory extensionFactory, IOptions <OneDasOptions> options, ILoggerFactory loggerFactory)
{
JObject jobject;
VersionRange versionRange;
_extensionFactory = extensionFactory;
_options = options.Value;
// settings
_settings = new Settings(_options.NugetDirectoryPath);
_settings.SetValues(ConfigurationConstants.PackageSources, new List <SettingValue>()
{
new SettingValue("NuGet", "https://api.nuget.org/v3/index.json", false)
});
_settings.SetValues(ConfigurationConstants.PackageSources, new List <SettingValue>()
{
new SettingValue("MyGet (CI)", "https://www.myget.org/F/onedas/api/v3/index.json", false)
});
if (!File.Exists(_options.NugetProjectFilePath))
{
jobject = new JObject();
versionRange = new VersionRange(new NuGetVersion("2.0.3"));
JsonConfigUtility.AddFramework(jobject, FrameworkConstants.CommonFrameworks.NetStandard20);
JsonConfigUtility.AddDependency(jobject, new PackageDependency("NETStandard.Library", versionRange));
jobject.Add("runtimes", new JObject(new JProperty(_options.RestoreRuntimeId, new JObject())));
File.WriteAllText(_options.NugetProjectFilePath, jobject.ToString(Formatting.Indented));
}
_project = new OneDasNugetProject(_options.NugetProjectFilePath);
_projectContext = new OneDasNuGetProjectContext(loggerFactory.CreateLogger("Nuget"));
_sourceRepositoryProvider = this.CreateSourceRepositoryProvider();
_packageManager = this.CreateNuGetPackageManager(_sourceRepositoryProvider);
this.PackageSourceSet = SettingsUtility.GetEnabledSources(_settings).ToList();
}
public void JsonConfigUtility_VerifyPackagesAreSortedInProjectJson()
{
// Arrange
var json = BasicConfig;
// Act
JsonConfigUtility.AddDependency(json, new PackageDependency("testpackageb", VersionRange.Parse("1.0.0")));
JsonConfigUtility.AddDependency(json, new PackageDependency("testpackageE", VersionRange.Parse("2.0.0")));
JsonConfigUtility.AddDependency(json, new PackageDependency("testpackageA", VersionRange.Parse("1.0.0")));
JsonConfigUtility.AddDependency(json, new PackageDependency("testpackaged", VersionRange.Parse("4.0.0")));
JsonConfigUtility.AddDependency(json, new PackageDependency("testpackageC", VersionRange.Parse("1.0.0")));
JToken val = null;
json.TryGetValue("dependencies", out val);
// Assert
Assert.Equal("testpackageA", ((JProperty)json["dependencies"].Children().First()).Name);
Assert.Equal("testpackageb", ((JProperty)json["dependencies"].Children().Skip(1).First()).Name);
Assert.Equal("testpackageC", ((JProperty)json["dependencies"].Children().Skip(2).First()).Name);
Assert.Equal("testpackaged", ((JProperty)json["dependencies"].Children().Skip(3).First()).Name);
Assert.Equal("testpackageE", ((JProperty)json["dependencies"].Children().Skip(4).First()).Name);
}
public void GetDependencies_ParsesIdAndVersion()
{
// Arrange
var json = JObject.Parse(
@"
{
""dependencies"": {
""PackageA"": ""1.0.0"",
""PackageC"": { ""type"": ""build"", version: ""2.0.0-beta2"" }
}
}");
// Act
var dependencies = JsonConfigUtility.GetDependencies(json).ToList();
// Assert
Assert.Equal(2, dependencies.Count);
Assert.Equal("PackageA", dependencies[0].Id);
Assert.Equal(VersionRange.Parse("1.0.0"), dependencies[0].VersionRange);
Assert.Equal("PackageC", dependencies[1].Id);
Assert.Equal(VersionRange.Parse("2.0.0-beta2"), dependencies[1].VersionRange);
}
public async Task BuildIntegratedNuGetProject_IsRestoreRequiredMissingPackage()
{
// Arrange
var projectName = "testproj";
using (var solutionManager = new TestSolutionManager(false))
{
var projectFolder = new DirectoryInfo(Path.Combine(solutionManager.SolutionDirectory, projectName));
projectFolder.Create();
var projectConfig = new FileInfo(Path.Combine(projectFolder.FullName, "project.json"));
var msbuildProjectPath = new FileInfo(Path.Combine(projectFolder.FullName, $"{projectName}.csproj"));
BuildIntegrationTestUtility.CreateConfigJson(projectConfig.FullName);
var json = JObject.Parse(File.ReadAllText(projectConfig.FullName));
JsonConfigUtility.AddDependency(json, new NuGet.Packaging.Core.PackageDependency("nuget.versioning", VersionRange.Parse("1.0.7")));
using (var writer = new StreamWriter(projectConfig.FullName))
{
writer.Write(json.ToString());
}
var sources = new List <SourceRepository> {
};
var projectTargetFramework = NuGetFramework.Parse("uap10.0");
var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(projectTargetFramework, new TestNuGetProjectContext());
var project = new ProjectJsonNuGetProject(projectConfig.FullName, msbuildProjectPath.FullName);
solutionManager.NuGetProjects.Add(project);
var testLogger = new TestLogger();
var settings = Settings.LoadSpecificSettings(solutionManager.SolutionDirectory, "NuGet.Config");
var restoreContext = new DependencyGraphCacheContext(testLogger, settings);
var providersCache = new RestoreCommandProvidersCache();
await DependencyGraphRestoreUtility.RestoreAsync(
solutionManager,
await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext),
restoreContext,
providersCache,
(c) => { },
sources,
Guid.Empty,
false,
true,
testLogger,
CancellationToken.None);
var noOpRestoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync(
solutionManager,
await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext),
restoreContext,
providersCache,
(c) => { },
sources,
Guid.Empty,
false,
true,
testLogger,
CancellationToken.None);
foreach (var restoreSummary in noOpRestoreSummaries)
{
Assert.True(restoreSummary.NoOpRestore);
}
var resolver = new VersionFolderPathResolver(solutionManager.GlobalPackagesFolder);
var pathToDelete = resolver.GetInstallPath("nuget.versioning", NuGetVersion.Parse("1.0.7"));
TestFileSystemUtility.DeleteRandomTestFolder(pathToDelete);
var restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync(
solutionManager,
await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext),
restoreContext,
new RestoreCommandProvidersCache(),
(c) => { },
sources,
Guid.Empty,
false,
true,
testLogger,
CancellationToken.None);
foreach (var restoreSummary in restoreSummaries)
{
Assert.True(restoreSummary.Success);
Assert.False(restoreSummary.NoOpRestore);
}
}
}
public async Task BuildIntegratedNuGetProject_IsRestoreRequiredChangedSha512()
{
// Arrange
var projectName = "testproj";
using (var packagesFolder = TestDirectory.Create())
using (var rootFolder = TestDirectory.Create())
{
var projectFolder = new DirectoryInfo(Path.Combine(rootFolder, projectName));
projectFolder.Create();
var projectConfig = new FileInfo(Path.Combine(projectFolder.FullName, "project.json"));
var msbuildProjectPath = new FileInfo(Path.Combine(projectFolder.FullName, $"{projectName}.csproj"));
BuildIntegrationTestUtility.CreateConfigJson(projectConfig.FullName);
var json = JObject.Parse(File.ReadAllText(projectConfig.FullName));
JsonConfigUtility.AddDependency(json, new PackageDependency("nuget.versioning", VersionRange.Parse("1.0.7")));
using (var writer = new StreamWriter(projectConfig.FullName))
{
writer.Write(json.ToString());
}
var sources = new List <SourceRepository>
{
Repository.Factory.GetVisualStudio("https://www.nuget.org/api/v2/")
};
var testLogger = new TestLogger();
var projectTargetFramework = NuGetFramework.Parse("uap10.0");
var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(projectTargetFramework, new TestNuGetProjectContext());
var project = new ProjectJsonBuildIntegratedNuGetProject(projectConfig.FullName, msbuildProjectPath.FullName, msBuildNuGetProjectSystem);
var solutionManager = new TestSolutionManager(false);
solutionManager.NuGetProjects.Add(project);
var restoreContext = new DependencyGraphCacheContext(testLogger);
await DependencyGraphRestoreUtility.RestoreAsync(
solutionManager,
restoreContext,
new RestoreCommandProvidersCache(),
(c) => { },
sources,
packagesFolder,
NullSettings.Instance,
testLogger,
CancellationToken.None);
var resolver = new VersionFolderPathResolver(packagesFolder);
var hashPath = resolver.GetHashPath("nuget.versioning", NuGetVersion.Parse("1.0.7"));
using (var writer = new StreamWriter(hashPath))
{
writer.Write("ANAWESOMELYWRONGHASH!!!");
}
// Act
var actual = await project.IsRestoreRequired(
new[] { resolver },
new HashSet <PackageIdentity>(),
restoreContext);
// Assert
Assert.True(actual);
}
}
public async Task BuildIntegratedNuGetProject_IsRestoreRequiredChangedSha512()
{
// Arrange
var projectName = "testproj";
using (var solutionManager = new TestSolutionManager(false))
{
var projectFolder = new DirectoryInfo(Path.Combine(solutionManager.SolutionDirectory, projectName));
projectFolder.Create();
var projectConfig = new FileInfo(Path.Combine(projectFolder.FullName, "project.json"));
var msbuildProjectPath = new FileInfo(Path.Combine(projectFolder.FullName, $"{projectName}.csproj"));
BuildIntegrationTestUtility.CreateConfigJson(projectConfig.FullName);
var json = JObject.Parse(File.ReadAllText(projectConfig.FullName));
JsonConfigUtility.AddDependency(json, new PackageDependency("nuget.versioning", VersionRange.Parse("1.0.7")));
using (var writer = new StreamWriter(projectConfig.FullName))
{
writer.Write(json.ToString());
}
var sources = new List <SourceRepository> {
};
var testLogger = new TestLogger();
var settings = Settings.LoadSpecificSettings(solutionManager.SolutionDirectory, "NuGet.Config");
var project = new ProjectJsonNuGetProject(projectConfig.FullName, msbuildProjectPath.FullName);
solutionManager.NuGetProjects.Add(project);
var restoreContext = new DependencyGraphCacheContext(testLogger, settings);
var providersCache = new RestoreCommandProvidersCache();
var dgSpec1 = await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext);
await DependencyGraphRestoreUtility.RestoreAsync(
solutionManager,
dgSpec1,
restoreContext,
providersCache,
(c) => { },
sources,
Guid.Empty,
false,
true,
testLogger,
CancellationToken.None);
var dgSpec2 = await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext);
var noOpRestoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync(
solutionManager,
dgSpec2,
restoreContext,
providersCache,
(c) => { },
sources,
Guid.Empty,
false,
true,
testLogger,
CancellationToken.None);
foreach (var restoreSummary in noOpRestoreSummaries)
{
Assert.True(restoreSummary.NoOpRestore);
}
var resolver = new VersionFolderPathResolver(solutionManager.GlobalPackagesFolder);
var hashPath = resolver.GetHashPath("nuget.versioning", NuGetVersion.Parse("1.0.7"));
File.Delete(hashPath);
var restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync(
solutionManager,
await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext),
restoreContext,
new RestoreCommandProvidersCache(),
(c) => { },
sources,
Guid.Empty,
false,
true,
testLogger,
CancellationToken.None);
foreach (var restoreSummary in restoreSummaries)
{
Assert.True(restoreSummary.Success);
Assert.False(restoreSummary.NoOpRestore);
}
var filePath = Path.Combine(
NuGetEnvironment.GetFolderPath(NuGetFolderPath.Temp),
"nuget-dg",
"nugetSpec.dg");
Assert.True(File.Exists(filePath));
}
}
public async Task BuildIntegratedNuGetProject_RestoreFailed_PersistDGSpecFile()
{
// Arrange
var projectName = "testproj";
using (var packagesFolder = TestDirectory.Create())
using (var rootFolder = TestDirectory.Create())
{
var projectFolder = new DirectoryInfo(Path.Combine(rootFolder, projectName));
projectFolder.Create();
var projectConfig = new FileInfo(Path.Combine(projectFolder.FullName, "project.json"));
var msbuildProjectPath = new FileInfo(Path.Combine(projectFolder.FullName, $"{projectName}.csproj"));
BuildIntegrationTestUtility.CreateConfigJson(projectConfig.FullName);
var json = JObject.Parse(File.ReadAllText(projectConfig.FullName));
// invalid version for nuget.versioning package which will make this restore fail.
JsonConfigUtility.AddDependency(json, new PackageDependency("nuget.versioning", VersionRange.Parse("3000.0.0")));
using (var writer = new StreamWriter(projectConfig.FullName))
{
writer.Write(json.ToString());
}
var sources = new List <SourceRepository> {
};
var testLogger = new TestLogger();
var settings = new Settings(rootFolder);
settings.SetValue(SettingsUtility.ConfigSection, "globalPackagesFolder", packagesFolder);
var project = new ProjectJsonNuGetProject(projectConfig.FullName, msbuildProjectPath.FullName);
var solutionManager = new TestSolutionManager(false);
solutionManager.NuGetProjects.Add(project);
var restoreContext = new DependencyGraphCacheContext(testLogger, settings);
var providersCache = new RestoreCommandProvidersCache();
var dgSpec = await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext);
var restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync(
solutionManager,
restoreContext,
providersCache,
(c) => { },
sources,
false,
dgSpec,
testLogger,
CancellationToken.None);
foreach (var restoreSummary in restoreSummaries)
{
Assert.False(restoreSummary.Success);
}
var filePath = Path.Combine(
NuGetEnvironment.GetFolderPath(NuGetFolderPath.Temp),
"nuget-dg",
"nugetSpec.dg");
Assert.True(File.Exists(filePath));
}
}
public async Task BuildIntegratedNuGetProject_IsRestoreRequiredWithNoChangesFallbackFolder()
{
// Arrange
var projectName = "testproj";
using (var globalFolder = TestDirectory.Create())
using (var fallbackFolder = TestDirectory.Create())
using (var rootFolder = TestDirectory.Create())
{
var projectFolder = new DirectoryInfo(Path.Combine(rootFolder, projectName));
projectFolder.Create();
var projectConfig = new FileInfo(Path.Combine(projectFolder.FullName, "project.json"));
var msbuildProjectPath = new FileInfo(Path.Combine(projectFolder.FullName, $"{projectName}.csproj"));
BuildIntegrationTestUtility.CreateConfigJson(projectConfig.FullName);
var json = JObject.Parse(File.ReadAllText(projectConfig.FullName));
JsonConfigUtility.AddDependency(json, new NuGet.Packaging.Core.PackageDependency("nuget.versioning", VersionRange.Parse("1.0.7")));
using (var writer = new StreamWriter(projectConfig.FullName))
{
writer.Write(json.ToString());
}
var sources = new List <SourceRepository>
{
Repository.Factory.GetVisualStudio("https://www.nuget.org/api/v2/")
};
var projectTargetFramework = NuGetFramework.Parse("uap10.0");
var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(projectTargetFramework, new TestNuGetProjectContext());
var project = new ProjectJsonNuGetProject(projectConfig.FullName, msbuildProjectPath.FullName);
// Restore to the fallback folder
var solutionManager = new TestSolutionManager(false);
solutionManager.NuGetProjects.Add(project);
var testLogger = new TestLogger();
var restoreContext = new DependencyGraphCacheContext(testLogger, NullSettings.Instance);
await DependencyGraphRestoreUtility.RestoreAsync(
solutionManager,
restoreContext,
new RestoreCommandProvidersCache(),
(c) => { },
sources,
false,
await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext),
testLogger,
CancellationToken.None);
var packageFolders = new List <string> {
globalFolder, fallbackFolder
};
// Act
//var actual = await project.IsRestoreRequired(
// packageFolders.Select(p => new VersionFolderPathResolver(p)),
// new HashSet<PackageIdentity>(),
// restoreContext);
// Assert
//Assert.False(actual);
}
}
public async Task BuildIntegratedNuGetProject_IsRestoreRequiredChangedSha512()
{
// Arrange
var projectName = "testproj";
using (var packagesFolder = TestDirectory.Create())
using (var rootFolder = TestDirectory.Create())
{
var projectFolder = new DirectoryInfo(Path.Combine(rootFolder, projectName));
projectFolder.Create();
var projectConfig = new FileInfo(Path.Combine(projectFolder.FullName, "project.json"));
var msbuildProjectPath = new FileInfo(Path.Combine(projectFolder.FullName, $"{projectName}.csproj"));
BuildIntegrationTestUtility.CreateConfigJson(projectConfig.FullName);
var json = JObject.Parse(File.ReadAllText(projectConfig.FullName));
JsonConfigUtility.AddDependency(json, new PackageDependency("nuget.versioning", VersionRange.Parse("1.0.7")));
using (var writer = new StreamWriter(projectConfig.FullName))
{
writer.Write(json.ToString());
}
var sources = new List <SourceRepository> {
};
var testLogger = new TestLogger();
var settings = new Settings(rootFolder);
settings.SetValue(SettingsUtility.ConfigSection, "globalPackagesFolder", packagesFolder);
var project = new ProjectJsonNuGetProject(projectConfig.FullName, msbuildProjectPath.FullName);
var solutionManager = new TestSolutionManager(false);
solutionManager.NuGetProjects.Add(project);
var restoreContext = new DependencyGraphCacheContext(testLogger, settings);
var providersCache = new RestoreCommandProvidersCache();
var dgSpec1 = await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext);
await DependencyGraphRestoreUtility.RestoreAsync(
solutionManager,
restoreContext,
providersCache,
(c) => { },
sources,
false,
dgSpec1,
testLogger,
CancellationToken.None);
var dgSpec2 = await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext);
var noOpRestoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync(
solutionManager,
restoreContext,
providersCache,
(c) => { },
sources,
false,
dgSpec2,
testLogger,
CancellationToken.None);
foreach (var restoreSummary in noOpRestoreSummaries)
{
Assert.True(restoreSummary.NoOpRestore);
}
var resolver = new VersionFolderPathResolver(packagesFolder);
var hashPath = resolver.GetHashPath("nuget.versioning", NuGetVersion.Parse("1.0.7"));
using (var writer = new StreamWriter(hashPath))
{
writer.Write("ANAWESOMELYWRONGHASH!!!");
}
var restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync(
solutionManager,
restoreContext,
new RestoreCommandProvidersCache(),
(c) => { },
sources,
false,
await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext),
testLogger,
CancellationToken.None);
foreach (var restoreSummary in restoreSummaries)
{
Assert.True(restoreSummary.Success);
Assert.False(restoreSummary.NoOpRestore);
}
}
}
public async Task BuildIntegratedNuGetProject_IsRestoreRequiredWithNoChanges()
{
// Arrange
var projectName = "testproj";
using (var packagesFolder = TestDirectory.Create())
using (var rootFolder = TestDirectory.Create())
{
var projectFolder = new DirectoryInfo(Path.Combine(rootFolder, projectName));
projectFolder.Create();
var projectConfig = new FileInfo(Path.Combine(projectFolder.FullName, "project.json"));
var msbuildProjectPath = new FileInfo(Path.Combine(projectFolder.FullName, $"{projectName}.csproj"));
BuildIntegrationTestUtility.CreateConfigJson(projectConfig.FullName);
var json = JObject.Parse(File.ReadAllText(projectConfig.FullName));
JsonConfigUtility.AddDependency(json, new NuGet.Packaging.Core.PackageDependency("nuget.versioning", VersionRange.Parse("1.0.7")));
using (var writer = new StreamWriter(projectConfig.FullName))
{
writer.Write(json.ToString());
}
var sources = new List <SourceRepository>
{
Repository.Factory.GetVisualStudio("https://www.nuget.org/api/v2/")
};
var projectTargetFramework = NuGetFramework.Parse("uap10.0");
var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(projectTargetFramework, new TestNuGetProjectContext());
var project = new ProjectJsonNuGetProject(projectConfig.FullName, msbuildProjectPath.FullName);
var effectiveGlobalPackagesFolder = SettingsUtility.GetGlobalPackagesFolder(NullSettings.Instance);
var solutionManager = new TestSolutionManager(false);
solutionManager.NuGetProjects.Add(project);
var testLogger = new TestLogger();
var settings = new Settings(rootFolder);
settings.SetValue(SettingsUtility.ConfigSection, "globalPackagesFolder", packagesFolder);
var providersCache = new RestoreCommandProvidersCache();
var restoreContext = new DependencyGraphCacheContext(testLogger, settings);
await DependencyGraphRestoreUtility.RestoreAsync(
solutionManager,
restoreContext,
providersCache,
(c) => { },
sources,
false,
await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext),
testLogger,
CancellationToken.None);
var noOpRestoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync(
solutionManager,
restoreContext,
providersCache,
(c) => { },
sources,
false,
await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext),
testLogger,
CancellationToken.None);
foreach (var restoreSummary in noOpRestoreSummaries)
{
Assert.True(restoreSummary.NoOpRestore);
}
}
}
