public void AddProjectRestoreInfo_TriggersEvent_WithEventHandler_WithReset()
{
// Arrange
var target = new ProjectSystemCache();
var projectNames = GetTestProjectNames();
var projectNamesFromFullPath = ProjectNames.FromFullProjectPath(projectNames.FullName);
var projectRestoreInfo = new DependencyGraphSpec();
var eventCount = 0;
target.CacheUpdated += delegate(object sender, NuGetEventArgs <string> e)
{
if (target.TestResetDirtyFlag())
{
eventCount++;
}
};
// Act
target.AddProjectRestoreInfo(projectNamesFromFullPath, projectRestoreInfo, additionalMessages: null);
target.AddProject(projectNames, vsProjectAdapter: null, nuGetProject: null);
// Assert
DependencyGraphSpec actual;
ProjectNames names;
var getPackageSpecSuccess = target.TryGetProjectRestoreInfo(projectNames.FullName, out actual, out _);
var getProjectNameSuccess = target.TryGetProjectNames(projectNames.UniqueName, out names);
Assert.True(getPackageSpecSuccess);
Assert.True(getProjectNameSuccess);
Assert.Same(projectRestoreInfo, actual);
Assert.Equal(@"folder\project", names.CustomUniqueName);
Assert.Equal(target.IsCacheDirty, 0);
Assert.Equal(eventCount, 1);
}
public void AddProjectRestoreInfo_AfterAddProject_UpdatesCacheEntry()
{
// Arrange
var target = new ProjectSystemCache();
var projectNames = GetTestProjectNames();
var projectNamesFromFullPath = ProjectNames.FromFullProjectPath(projectNames.FullName);
var projectRestoreInfo = new DependencyGraphSpec();
target.AddProject(projectNames, vsProjectAdapter: null, nuGetProject: null);
// Act
target.AddProjectRestoreInfo(projectNamesFromFullPath, projectRestoreInfo, additionalMessages: null);
// Assert
var getPackageSpecSuccess = target.TryGetProjectRestoreInfo(projectNames.FullName, out var actual, out _);
var getProjectNameFromUniqueNameSuccess = target.TryGetProjectNames(projectNames.UniqueName, out var names1);
var getProjectNameFromFullNameSuccess = target.TryGetProjectNames(projectNames.FullName, out var names2);
Assert.True(getPackageSpecSuccess);
Assert.True(getProjectNameFromUniqueNameSuccess);
Assert.True(getProjectNameFromFullNameSuccess);
Assert.Same(projectRestoreInfo, actual);
Assert.Equal(@"folder\project", names1.CustomUniqueName);
Assert.Equal(@"folder\project", names2.CustomUniqueName);
}
public void AddProject_AfterAddProjectRestoreInfo_UpdatesCacheEntry()
{
// Arrange
var target = new ProjectSystemCache();
var projectNames = new ProjectNames(
fullName: @"C:\src\project\project.csproj",
uniqueName: @"folder\project",
shortName: "project",
customUniqueName: @"folder\project");
var projectNamesFromFullPath = ProjectNames.FromFullProjectPath(@"C:\src\project\project.csproj");
var projectRestoreInfo = new DependencyGraphSpec();
target.AddProjectRestoreInfo(projectNamesFromFullPath, projectRestoreInfo);
// Act
target.AddProject(projectNames, vsProjectAdapter: null, nuGetProject: null);
// Assert
DependencyGraphSpec actual;
ProjectNames names;
var getPackageSpecSuccess = target.TryGetProjectRestoreInfo(projectNames.FullName, out actual);
var getProjectNameSuccess = target.TryGetProjectNames(projectNames.UniqueName, out names);
Assert.True(getPackageSpecSuccess);
Assert.True(getProjectNameSuccess);
Assert.Same(projectRestoreInfo, actual);
Assert.Equal(@"folder\project", names.CustomUniqueName);
}
public void AddProject_AfterAddProjectRestoreInfoWithNullProject_DoesNotUpdatesCacheEntryProjectId()
{
// Arrange
var target = new ProjectSystemCache();
var projectNames = ProjectNames.FromFullProjectPath(@"C:\src\project\project.csproj");
var projectSpec = new PackageSpec()
{
ProjectId = string.Empty,
Name = projectNames.UniqueName,
RestoreMetadata = new ProjectRestoreMetadata()
{
ProjectUniqueName = projectNames.UniqueName
}
};
var projectRestoreInfo = new DependencyGraphSpec();
projectRestoreInfo.AddProject(projectSpec);
target.AddProjectRestoreInfo(projectNames, projectRestoreInfo);
// Act
target.AddProject(projectNames, vsProjectAdapter: null, nuGetProject: null);
// Assert
var getPackageSpecSuccess = target.TryGetProjectRestoreInfo(projectNames.FullName, out var actual);
// Assert
getPackageSpecSuccess.Should().BeTrue();
actual.Projects.Count.Should().Be(1);
actual.Projects.First().ProjectId.Should().Be(string.Empty);
}
public void AddProjectRestoreInfo_TriggersMultipleEvent_WithEventHandler_WithReset()
{
// Arrange
var target = new ProjectSystemCache();
var projectNames = GetTestProjectNames();
var projectRestoreInfo = new DependencyGraphSpec();
var eventCount = 0;
target.CacheUpdated += delegate(object sender, NuGetEventArgs <string> e)
{
if (target.TestResetDirtyFlag())
{
eventCount++;
}
};
// Act
target.AddProjectRestoreInfo(projectNames, projectRestoreInfo, additionalMessages: null);
target.AddProjectRestoreInfo(projectNames, projectRestoreInfo, additionalMessages: null);
target.AddProjectRestoreInfo(projectNames, projectRestoreInfo, additionalMessages: null);
target.AddProjectRestoreInfo(projectNames, projectRestoreInfo, additionalMessages: null);
// Assert
Assert.Equal(target.IsCacheDirty, 0);
Assert.Equal(eventCount, 4);
}
public void AddProject_RemoveProject_Clear_TriggerNoEvent_WithEventHandler()
{
// Arrange
var target = new ProjectSystemCache();
var projectNames = GetTestProjectNames();
var projectRestoreInfo = new DependencyGraphSpec();
var eventCount = 0;
target.CacheUpdated += delegate(object sender, NuGetEventArgs <string> e)
{
if (target.TestResetDirtyFlag())
{
eventCount++;
}
};
// Act
target.AddProject(projectNames, vsProjectAdapter: null, nuGetProject: null);
target.RemoveProject(projectNames.FullName);
target.Clear();
// Assert
Assert.Equal(target.IsCacheDirty, 0);
Assert.Equal(eventCount, 0);
}
public void AddProjectRestoreInfo_TriggersEvent_WithEventHandler_NoReset()
{
// Arrange
var target = new ProjectSystemCache();
var projectNames = GetTestProjectNames();
var projectRestoreInfo = new DependencyGraphSpec();
var eventCount = 0;
target.CacheUpdated += delegate(object sender, NuGetEventArgs <string> e)
{
eventCount++;
};
// Act
target.AddProjectRestoreInfo(projectNames, projectRestoreInfo, additionalMessages: null);
target.AddProjectRestoreInfo(projectNames, projectRestoreInfo, additionalMessages: null);
target.AddProject(projectNames, vsProjectAdapter: null, nuGetProject: null);
// Assert
DependencyGraphSpec actual;
ProjectNames names;
var getPackageSpecSuccess = target.TryGetProjectRestoreInfo(projectNames.FullName, out actual, out _);
var getProjectNameSuccess = target.TryGetProjectNames(projectNames.UniqueName, out names);
Assert.True(getPackageSpecSuccess);
Assert.True(getProjectNameSuccess);
Assert.Same(projectRestoreInfo, actual);
Assert.Equal(@"folder\project", names.CustomUniqueName);
// Since no listener resets the dirty flag, the cache remains dirty and only 1 event is raised.
Assert.Equal(target.IsCacheDirty, 1);
Assert.Equal(eventCount, 1);
}
public void AddProject_AfterAddProjectRestoreInfoWithProjectId_DoesNotUpdatesCacheEntryProjectId()
{
// Arrange
var target = new ProjectSystemCache();
var projectNames = ProjectNames.FromFullProjectPath(@"C:\src\project\project.csproj");
var originalProjectSpec = new PackageSpec()
{
ProjectId = Guid.NewGuid().ToString(),
Name = projectNames.UniqueName,
RestoreMetadata = new ProjectRestoreMetadata()
{
ProjectUniqueName = projectNames.UniqueName
}
};
var projectRestoreInfo = new DependencyGraphSpec();
var nugetProject = new TestNuGetProject(projectNames.UniqueName, new List <PackageReference>());
projectRestoreInfo.AddProject(originalProjectSpec);
target.AddProjectRestoreInfo(projectNames, projectRestoreInfo);
// Act
target.AddProject(projectNames, vsProjectAdapter: null, nuGetProject: nugetProject);
// Assert
var getPackageSpecSuccess = target.TryGetProjectRestoreInfo(projectNames.FullName, out var actual);
// Assert
getPackageSpecSuccess.Should().BeTrue();
actual.Projects.Count.Should().Be(1);
actual.Projects.First().ProjectId.Should().Be(originalProjectSpec.ProjectId);
}
public void AddProjectRestoreInfo_TriggersNoEvent_NoEventHandler()
{
// Arrange
var target = new ProjectSystemCache();
var projectNames = new ProjectNames(
fullName: @"C:\src\project\project.csproj",
uniqueName: @"folder\project",
shortName: "project",
customUniqueName: @"folder\project");
var projectNamesFromFullPath = ProjectNames.FromFullProjectPath(@"C:\src\project\project.csproj");
var projectRestoreInfo = new DependencyGraphSpec();
// Act
target.AddProjectRestoreInfo(projectNamesFromFullPath, projectRestoreInfo);
target.AddProject(projectNames, vsProjectAdapter: null, nuGetProject: null);
// Assert
DependencyGraphSpec actual;
ProjectNames names;
var getPackageSpecSuccess = target.TryGetProjectRestoreInfo(projectNames.FullName, out actual);
var getProjectNameSuccess = target.TryGetProjectNames(projectNames.UniqueName, out names);
Assert.True(getPackageSpecSuccess);
Assert.True(getProjectNameSuccess);
Assert.Same(projectRestoreInfo, actual);
Assert.Equal(@"folder\project", names.CustomUniqueName);
// Cache remains clean since no one is listening to the cache events
Assert.Equal(target.IsCacheDirty, 0);
}
public void TryGetDTEProject_ReturnsNullWhenShortNameIsAmbiguous()
{
// Arrange
var target = new ProjectSystemCache();
var projectNamesA = new ProjectNames(
fullName: @"C:\src\projectA\project.csproj",
uniqueName: @"folderA\project",
shortName: "project",
customUniqueName: @"folderA\project",
projectId: _projectGuid1);
var projectNamesB = new ProjectNames(
fullName: @"C:\src\projectB\project.csproj",
uniqueName: @"folderB\project",
shortName: projectNamesA.ShortName,
customUniqueName: @"folderB\project",
projectId: _projectGuid2);
target.AddProject(projectNamesA, vsProjectAdapter: null, nuGetProject: null);
target.AddProject(projectNamesB, vsProjectAdapter: null, nuGetProject: null);
IVsProjectAdapter actual;
// Act
var success = target.TryGetVsProjectAdapter(projectNamesA.ShortName, out actual);
// Assert
Assert.False(success, "The project should not have been fetched from the cache by short name.");
Assert.Null(actual);
}
public void AddProject_RemoveProject_Clear_TriggerNoEvent_WithEventHandler()
{
// Arrange
var target = new ProjectSystemCache();
var projectNames = new ProjectNames(
fullName: @"C:\src\project\project.csproj",
uniqueName: @"folder\project",
shortName: "project",
customUniqueName: @"folder\project");
var projectNamesFromFullPath = ProjectNames.FromFullProjectPath(@"C:\src\project\project.csproj");
var projectRestoreInfo = new DependencyGraphSpec();
var eventCount = 0;
target.CacheUpdated += delegate(object sender, NuGetEventArgs <string> e)
{
if (target.TestResetDirtyFlag())
{
eventCount++;
}
};
// Act
target.AddProject(projectNames, vsProjectAdapter: null, nuGetProject: null);
target.RemoveProject(projectNames.FullName);
target.Clear();
// Assert
Assert.Equal(target.IsCacheDirty, 0);
Assert.Equal(eventCount, 0);
}
public async Task GetInstalledVersion_WithFloating_WithAssetsFile_ReturnsVersionsFromAssetsSpecs()
{
using (var testDirectory = TestDirectory.Create())
{
// Setup
var projectName = "project1";
var projectFullPath = Path.Combine(testDirectory.Path, projectName + ".csproj");
// Project
var projectCache = new ProjectSystemCache();
IVsProjectAdapter projectAdapter = (new Mock <IVsProjectAdapter>()).Object;
var project = CreateNetCorePackageReferenceProject(projectName, projectFullPath, projectCache);
var projectNames = GetTestProjectNames(projectFullPath, projectName);
var packageSpec = GetPackageSpec(projectName, projectFullPath, "[*, )");
// Restore info
var projectRestoreInfo = ProjectJsonTestHelpers.GetDGSpecFromPackageSpecs(packageSpec);
projectCache.AddProjectRestoreInfo(projectNames, projectRestoreInfo, new List <IAssetsLogMessage>());
projectCache.AddProject(projectNames, projectAdapter, project).Should().BeTrue();
// Package directories
var sources = new List <PackageSource>();
var packagesDir = new DirectoryInfo(Path.Combine(testDirectory, "globalPackages"));
var packageSource = new DirectoryInfo(Path.Combine(testDirectory, "packageSource"));
packagesDir.Create();
packageSource.Create();
sources.Add(new PackageSource(packageSource.FullName));
var logger = new TestLogger();
var request = new TestRestoreRequest(packageSpec, sources, packagesDir.FullName, logger)
{
LockFilePath = Path.Combine(testDirectory, "project.assets.json")
};
await SimpleTestPackageUtility.CreateFullPackageAsync(packageSource.FullName, "packageA", "4.0.0");
// Act
var command = new RestoreCommand(request);
var result = await command.ExecuteAsync();
await result.CommitAsync(logger, CancellationToken.None);
var packages = await project.GetInstalledPackagesAsync(CancellationToken.None);
// Asert
Assert.True(result.Success);
packages.Should().Contain(a => a.PackageIdentity.Equals(new PackageIdentity("packageA", new NuGetVersion("4.0.0"))));
var cache_packages = await project.GetInstalledPackagesAsync(CancellationToken.None);
cache_packages.Should().Contain(a => a.PackageIdentity.Equals(new PackageIdentity("packageA", new NuGetVersion("4.0.0"))));
}
}
private static void AddPackageDependency(ProjectSystemCache projectSystemCache, ProjectNames projectNames, PackageSpec packageSpec, SimpleTestPackageContext package)
{
var dependency = new LibraryDependency()
{
LibraryRange = new LibraryRange(
name: package.Id,
versionRange: new VersionRange(package.Identity.Version),
typeConstraint: LibraryDependencyTarget.Package)
};
packageSpec.TargetFrameworks.First().Dependencies.Add(dependency);
DependencyGraphSpec projectRestoreInfo = ProjectTestHelpers.GetDGSpecFromPackageSpecs(packageSpec);
projectSystemCache.AddProjectRestoreInfo(projectNames, projectRestoreInfo, Array.Empty <IAssetsLogMessage>());
}
public void TryGetVsProjectAdapter_ReturnsProjectByCustomUniqueName()
{
// Arrange
var target = new ProjectSystemCache();
var projectNames = GetTestProjectNames();
var vsProjectAdapter = new Mock <IVsProjectAdapter>();
target.AddProject(projectNames, vsProjectAdapter.Object, nuGetProject: null);
IVsProjectAdapter actual;
// Act
var success = target.TryGetVsProjectAdapter(projectNames.CustomUniqueName, out actual);
// Assert
Assert.True(success, "The project should have been fetched from the cache by custom unique name.");
Assert.Same(vsProjectAdapter.Object, actual);
}
public void TryGetDTEProject_ReturnsProjectWhenShortNameIsNotAmbiguous()
{
// Arrange
var target = new ProjectSystemCache();
var projectNames = GetTestProjectNames();
var vsProjectAdapter = new Mock <IVsProjectAdapter>();
target.AddProject(projectNames, vsProjectAdapter.Object, nuGetProject: null);
IVsProjectAdapter actual;
// Act
var success = target.TryGetVsProjectAdapter(projectNames.ShortName, out actual);
// Assert
Assert.True(success, "The project should have been fetched from the cache by short name.");
Assert.Same(vsProjectAdapter.Object, actual);
}
public async Task GetInstalledVersion_WithoutPackages_ReturnsEmpty()
{
using (var testDirectory = TestDirectory.Create())
{
// Setup
var projectName = "project1";
var projectFullPath = Path.Combine(testDirectory.Path, projectName + ".csproj");
// Project
var projectCache = new ProjectSystemCache();
IVsProjectAdapter projectAdapter = (new Mock <IVsProjectAdapter>()).Object;
var project = CreateNetCorePackageReferenceProject(projectName, projectFullPath, projectCache);
var projectNames = GetTestProjectNames(projectFullPath, projectName);
var packageSpec = GetPackageSpecNoPackages(projectName, projectFullPath);
// Restore info
var projectRestoreInfo = ProjectJsonTestHelpers.GetDGSpecFromPackageSpecs(packageSpec);
projectCache.AddProjectRestoreInfo(projectNames, projectRestoreInfo, new List <IAssetsLogMessage>());
projectCache.AddProject(projectNames, projectAdapter, project).Should().BeTrue();
// Package directories
var sources = new List <PackageSource>();
var packagesDir = new DirectoryInfo(Path.Combine(testDirectory, "globalPackages"));
var packageSource = new DirectoryInfo(Path.Combine(testDirectory, "packageSource"));
packagesDir.Create();
packageSource.Create();
sources.Add(new PackageSource(packageSource.FullName));
var logger = new TestLogger();
var request = new TestRestoreRequest(packageSpec, sources, packagesDir.FullName, logger);
// Act
var command = new RestoreCommand(request);
var result = await command.ExecuteAsync();
await result.CommitAsync(logger, CancellationToken.None);
var packages = await project.GetInstalledPackagesAsync(CancellationToken.None);
// Asert
packages.Should().BeEmpty();
}
}
public void AddProjectRestoreInfo_WithAdditionalMessages_ReturnsMessagesOnGet()
{
// Arrange
var target = new ProjectSystemCache();
var projectNames = GetTestProjectNames();
var additionalMessages = new List <IAssetsLogMessage>()
{
new AssetsLogMessage(Common.LogLevel.Error, Common.NuGetLogCode.NU1000, "Test error")
};
var projectRestoreInfo = new DependencyGraphSpec();
// Act
target.AddProjectRestoreInfo(projectNames, projectRestoreInfo, additionalMessages);
// Assert
target.TryGetProjectRestoreInfo(projectNames.FullName, out _, out var projectAdditionalMessages);
Assert.NotNull(projectAdditionalMessages);
Assert.Equal(additionalMessages.Count, projectAdditionalMessages.Count);
}
public async Task GetInstalledVersion_WithoutAssetsFile_ReturnsVersionsFromPackageSpecs()
{
using (var testDirectory = TestDirectory.Create())
{
// Setup
var projectName = "project1";
var projectFullPath = Path.Combine(testDirectory.Path, projectName + ".csproj");
// Project
var projectCache = new ProjectSystemCache();
IVsProjectAdapter projectAdapter = (new Mock <IVsProjectAdapter>()).Object;
var project = CreateNetCorePackageReferenceProject(projectName, projectFullPath, projectCache);
var projectNames = GetTestProjectNames(projectFullPath, projectName);
var packageSpec = GetPackageSpec(projectName, projectFullPath, "[2.0.0, )");
// Restore info
var projectRestoreInfo = ProjectJsonTestHelpers.GetDGSpecFromPackageSpecs(packageSpec);
projectCache.AddProjectRestoreInfo(projectNames, projectRestoreInfo, new List <IAssetsLogMessage>());
projectCache.AddProject(projectNames, projectAdapter, project).Should().BeTrue();
// Package directories
var sources = new List <PackageSource>();
var packagesDir = new DirectoryInfo(Path.Combine(testDirectory, "globalPackages"));
var packageSource = new DirectoryInfo(Path.Combine(testDirectory, "packageSource"));
packagesDir.Create();
packageSource.Create();
sources.Add(new PackageSource(packageSource.FullName));
var logger = new TestLogger();
// Act
var packages = await project.GetInstalledPackagesAsync(CancellationToken.None);
// Asert
packages.Should().Contain(a => a.PackageIdentity.Equals(new PackageIdentity("packageA", new NuGetVersion("2.0.0"))));
var cache_packages = await project.GetInstalledPackagesAsync(CancellationToken.None);
cache_packages.Should().Contain(a => a.PackageIdentity.Equals(new PackageIdentity("packageA", new NuGetVersion("2.0.0"))));
}
}
public void TryGetVsProjectAdapter_ReturnsProjectByUniqueName()
{
// Arrange
var target = new ProjectSystemCache();
var projectNames = new ProjectNames(
fullName: @"C:\src\project\project.csproj",
uniqueName: @"folder\project",
shortName: "project",
customUniqueName: @"folder\project");
var vsProjectAdapter = new Mock <IVsProjectAdapter>();
target.AddProject(projectNames, vsProjectAdapter.Object, nuGetProject: null);
IVsProjectAdapter actual;
// Act
var success = target.TryGetVsProjectAdapter(projectNames.UniqueName, out actual);
// Assert
Assert.True(success, "The project should have been fetched from the cache by unique name.");
Assert.Same(vsProjectAdapter.Object, actual);
}
public void TryGetDTEProject_ReturnsProjectWhenShortNameIsNotAmbiguous()
{
// Arrange
var target = new ProjectSystemCache();
var projectNames = new ProjectNames(
fullName: @"C:\src\project\project.csproj",
uniqueName: @"folder\project",
shortName: "project",
customUniqueName: @"folder\project");
var dteProject = new Mock <EnvDTE.Project>();
target.AddProject(projectNames, dteProject.Object, nuGetProject: null);
EnvDTE.Project actual;
// Act
var success = target.TryGetDTEProject(projectNames.ShortName, out actual);
// Assert
Assert.True(success, "The project should have been fetched from the cache by short name.");
Assert.Same(dteProject.Object, actual);
}
public void AddProjectRestoreInfo_TriggersEvent_WithEventHandler_NoReset()
{
// Arrange
var target = new ProjectSystemCache();
var projectNames = new ProjectNames(
fullName: @"C:\src\project\project.csproj",
uniqueName: @"folder\project",
shortName: "project",
customUniqueName: @"folder\project");
var projectNamesFromFullPath = ProjectNames.FromFullProjectPath(@"C:\src\project\project.csproj");
var projectRestoreInfo = new DependencyGraphSpec();
var eventCount = 0;
target.CacheUpdated += delegate(object sender, NuGetEventArgs <string> e)
{
eventCount++;
};
// Act
target.AddProjectRestoreInfo(projectNamesFromFullPath, projectRestoreInfo);
target.AddProjectRestoreInfo(projectNamesFromFullPath, projectRestoreInfo);
target.AddProject(projectNames, dteProject: null, nuGetProject: null);
// Assert
DependencyGraphSpec actual;
ProjectNames names;
var getPackageSpecSuccess = target.TryGetProjectRestoreInfo(projectNames.FullName, out actual);
var getProjectNameSuccess = target.TryGetProjectNames(projectNames.UniqueName, out names);
Assert.True(getPackageSpecSuccess);
Assert.True(getProjectNameSuccess);
Assert.Same(projectRestoreInfo, actual);
Assert.Equal(@"folder\project", names.CustomUniqueName);
// Since no listener resets the dirty flag, the cache remains dirty and only 1 event is raised.
Assert.Equal(target.IsCacheDirty, 1);
Assert.Equal(eventCount, 1);
}
public void AddProjectRestoreInfoSource_AfterAddProject_UpdatesCacheEntry()
{
// Arrange
var target = new ProjectSystemCache();
var projectNames = GetTestProjectNames();
object projectRestoreInfoSource = new();
target.AddProject(projectNames, vsProjectAdapter: null, nuGetProject: null);
// Act
target.AddProjectRestoreInfoSource(projectNames, projectRestoreInfoSource);
// Assert
var getProjectRestoreInfoSources = target.GetProjectRestoreInfoSources();
var getProjectNameFromUniqueNameSuccess = target.TryGetProjectNames(projectNames.UniqueName, out var names1);
var getProjectNameFromFullNameSuccess = target.TryGetProjectNames(projectNames.FullName, out var names2);
Assert.True(getProjectRestoreInfoSources.Any());
Assert.Equal(projectRestoreInfoSource, getProjectRestoreInfoSources.Single());
Assert.True(getProjectNameFromUniqueNameSuccess);
Assert.True(getProjectNameFromFullNameSuccess);
Assert.Equal(@"folder\project", names1.CustomUniqueName);
Assert.Equal(@"folder\project", names2.CustomUniqueName);
}
public void AddProjectRestoreInfoSource_Succeeds()
{
// Arrange
var target = new ProjectSystemCache();
var projectNames = GetTestProjectNames();
object projectRestoreInfoSource = new();
// Act
var result = target.AddProjectRestoreInfoSource(projectNames, projectRestoreInfoSource);
// Assert
Assert.True(result);
var getProjectRestoreInfoSources = target.GetProjectRestoreInfoSources();
var getProjectNameFromUniqueNameSuccess = target.TryGetProjectNames(projectNames.UniqueName, out var names1);
var getProjectNameFromFullNameSuccess = target.TryGetProjectNames(projectNames.FullName, out var names2);
Assert.True(getProjectRestoreInfoSources.Any());
Assert.Equal(projectRestoreInfoSource, getProjectRestoreInfoSources.Single());
Assert.True(getProjectNameFromUniqueNameSuccess);
Assert.True(getProjectNameFromFullNameSuccess);
Assert.Equal(@"folder\project", names1.CustomUniqueName);
Assert.Equal(@"folder\project", names2.CustomUniqueName);
}
public void AddProjectRestoreInfo_TriggersNoEvent_NoEventHandler()
{
// Arrange
var target = new ProjectSystemCache();
var projectNames = GetTestProjectNames();
var projectRestoreInfo = new DependencyGraphSpec();
// Act
target.AddProjectRestoreInfo(projectNames, projectRestoreInfo, additionalMessages: null);
target.AddProject(projectNames, vsProjectAdapter: null, nuGetProject: null);
// Assert
DependencyGraphSpec actual;
ProjectNames names;
var getPackageSpecSuccess = target.TryGetProjectRestoreInfo(projectNames.FullName, out actual, out _);
var getProjectNameSuccess = target.TryGetProjectNames(projectNames.UniqueName, out names);
Assert.True(getPackageSpecSuccess);
Assert.True(getProjectNameSuccess);
Assert.Same(projectRestoreInfo, actual);
Assert.Equal(@"folder\project", names.CustomUniqueName);
// Cache remains clean since no one is listening to the cache events
Assert.Equal(target.IsCacheDirty, 0);
}
public async Task GetInstallActionsAsync_WithProjectReferenceProject_WhenUpdatingPackage_ReturnsCorrectActions()
{
const string projectName = "a";
string projectId = Guid.NewGuid().ToString();
var projectSystemCache = new ProjectSystemCache();
using (TestDirectory testDirectory = TestDirectory.Create())
{
var packageV1 = new SimpleTestPackageContext(packageId: "b", version: "1.0.0");
var packageV2 = new SimpleTestPackageContext(packageV1.Id, version: "2.0.0");
string packageSourceDirectoryPath = Path.Combine(testDirectory, "packageSource");
await SimpleTestPackageUtility.CreateFolderFeedV3Async(
packageSourceDirectoryPath,
PackageSaveMode.Defaultv3,
packageV1,
packageV2);
var packageSource = new PackageSource(packageSourceDirectoryPath);
var packageSources = new List <PackageSource>()
{
packageSource
};
Initialize(packageSources);
string projectFullPath = Path.Combine(testDirectory.Path, $"{projectName}.csproj");
var unconfiguredProject = new Mock <UnconfiguredProject>();
var configuredProject = new Mock <ConfiguredProject>();
var projectServices = new Mock <ConfiguredProjectServices>();
var packageReferencesService = new Mock <IPackageReferencesService>();
var result = new Mock <IUnresolvedPackageReference>();
unconfiguredProject.Setup(x => x.GetSuggestedConfiguredProjectAsync())
.ReturnsAsync(configuredProject.Object);
configuredProject.SetupGet(x => x.Services)
.Returns(projectServices.Object);
projectServices.SetupGet(x => x.PackageReferences)
.Returns(packageReferencesService.Object);
packageReferencesService.Setup(x => x.AddAsync(It.IsNotNull <string>(), It.IsNotNull <string>()))
.ReturnsAsync(new AddReferenceResult <IUnresolvedPackageReference>(result.Object, added: true));
var nuGetProjectServices = new Mock <INuGetProjectServices>();
nuGetProjectServices.SetupGet(x => x.ScriptService)
.Returns(Mock.Of <IProjectScriptHostService>());
var project = new CpsPackageReferenceProject(
projectName: projectName,
projectUniqueName: projectFullPath,
projectFullPath: projectFullPath,
projectSystemCache,
unconfiguredProject.Object,
nuGetProjectServices.Object,
projectId);
PackageSpec packageSpec = CreatePackageSpec(
project.ProjectName,
Path.Combine(testDirectory, "package.spec"));
DependencyGraphSpec projectRestoreInfo = ProjectJsonTestHelpers.GetDGSpecFromPackageSpecs(packageSpec);
projectRestoreInfo.AddProject(packageSpec);
var projectNames = new ProjectNames(
fullName: projectFullPath,
uniqueName: projectFullPath,
shortName: projectName,
customUniqueName: projectName,
projectId: projectId);
projectSystemCache.AddProjectRestoreInfo(projectNames, projectRestoreInfo, Array.Empty <IAssetsLogMessage>());
_solutionManager.NuGetProjects.Add(project);
string[] projectIds = new[] { projectId };
string[] packageSourceNames = new[] { packageSource.Name };
await PerformOperationAsync(async (projectManager) =>
{
IReadOnlyList <ProjectAction> actions = await projectManager.GetInstallActionsAsync(
projectIds,
packageV1.Identity,
VersionConstraints.None,
includePrelease: true,
DependencyBehavior.Lowest,
packageSourceNames,
CancellationToken.None);
Assert.NotEmpty(actions);
Assert.Equal(1, actions.Count);
ProjectAction action = actions[0];
Assert.Equal(packageV1.Identity, action.PackageIdentity);
Assert.Equal(NuGetProjectActionType.Install, action.ProjectActionType);
Assert.Equal(projectId, action.ProjectId);
Assert.Equal(1, action.ImplicitActions.Count);
ImplicitProjectAction implicitAction = action.ImplicitActions[0];
Assert.Equal(packageV1.Identity, implicitAction.PackageIdentity);
Assert.Equal(NuGetProjectActionType.Install, implicitAction.ProjectActionType);
await projectManager.ExecuteActionsAsync(actions, CancellationToken.None);
});
await PerformOperationAsync(async (projectManager) =>
{
IReadOnlyList <ProjectAction> actions = await projectManager.GetInstallActionsAsync(
projectIds,
packageV2.Identity,
VersionConstraints.None,
includePrelease: true,
DependencyBehavior.Lowest,
packageSourceNames,
CancellationToken.None);
Assert.NotEmpty(actions);
Assert.Equal(1, actions.Count);
ProjectAction action = actions[0];
Assert.Equal(packageV2.Identity, action.PackageIdentity);
Assert.Equal(NuGetProjectActionType.Install, action.ProjectActionType);
Assert.Equal(projectId, action.ProjectId);
Assert.Equal(2, action.ImplicitActions.Count);
ImplicitProjectAction implicitAction = action.ImplicitActions[0];
Assert.Equal(packageV1.Identity, implicitAction.PackageIdentity);
Assert.Equal(NuGetProjectActionType.Uninstall, implicitAction.ProjectActionType);
implicitAction = action.ImplicitActions[1];
Assert.Equal(packageV2.Identity, implicitAction.PackageIdentity);
Assert.Equal(NuGetProjectActionType.Install, implicitAction.ProjectActionType);
});
}
}
public async Task GetInstallActionsAsync_WithPackagesConfigProject_WhenUpdatingPackage_ReturnsCorrectActions()
{
const string projectName = "a";
string projectId = Guid.NewGuid().ToString();
var projectSystemCache = new ProjectSystemCache();
using (TestDirectory testDirectory = TestDirectory.Create())
{
var packageV1 = new SimpleTestPackageContext(packageId: "b", version: "1.0.0");
var packageV2 = new SimpleTestPackageContext(packageV1.Id, version: "2.0.0");
string packageSourceDirectoryPath = Path.Combine(testDirectory, "packageSource");
await SimpleTestPackageUtility.CreateFolderFeedV3Async(
packageSourceDirectoryPath,
PackageSaveMode.Defaultv3,
packageV1,
packageV2);
var packageSource = new PackageSource(packageSourceDirectoryPath);
var packageSources = new List <PackageSource>()
{
packageSource
};
Initialize(packageSources);
string projectFullPath = Path.Combine(testDirectory.Path, $"{projectName}.csproj");
NuGetFramework targetFramework = NuGetFramework.Parse("net46");
var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(targetFramework, new TestNuGetProjectContext());
var project = new TestMSBuildNuGetProject(msBuildNuGetProjectSystem, testDirectory.Path, projectFullPath, projectId);
_solutionManager.NuGetProjects.Add(project);
string[] projectIds = new[] { projectId };
string[] packageSourceNames = new[] { packageSource.Name };
await PerformOperationAsync(async (projectManager) =>
{
IReadOnlyList <ProjectAction> actions = await projectManager.GetInstallActionsAsync(
projectIds,
packageV1.Identity,
VersionConstraints.None,
includePrelease: true,
DependencyBehavior.Lowest,
packageSourceNames,
CancellationToken.None);
Assert.NotEmpty(actions);
Assert.Equal(1, actions.Count);
ProjectAction action = actions[0];
Assert.Equal(packageV1.Identity, action.PackageIdentity);
Assert.Equal(NuGetProjectActionType.Install, action.ProjectActionType);
Assert.Equal(projectId, action.ProjectId);
Assert.Empty(action.ImplicitActions);
await projectManager.ExecuteActionsAsync(actions, CancellationToken.None);
});
await PerformOperationAsync(async (projectManager) =>
{
IReadOnlyList <ProjectAction> actions = await projectManager.GetInstallActionsAsync(
projectIds,
packageV2.Identity,
VersionConstraints.None,
includePrelease: true,
DependencyBehavior.Lowest,
packageSourceNames,
CancellationToken.None);
Assert.NotEmpty(actions);
Assert.Equal(2, actions.Count);
ProjectAction action = actions[0];
Assert.Equal(packageV1.Identity, action.PackageIdentity);
Assert.Equal(NuGetProjectActionType.Uninstall, action.ProjectActionType);
Assert.Equal(projectId, action.ProjectId);
action = actions[1];
Assert.Equal(packageV2.Identity, action.PackageIdentity);
Assert.Equal(NuGetProjectActionType.Install, action.ProjectActionType);
Assert.Equal(projectId, action.ProjectId);
});
}
}
private NetCorePackageReferenceProject CreateNetCorePackageReferenceProject(string projectName, string projectFullPath, ProjectSystemCache projectSystemCache)
{
var projectServices = new TestProjectSystemServices();
return(new NetCorePackageReferenceProject(
projectName: projectName,
projectUniqueName: projectName,
projectFullPath: projectFullPath,
projectSystemCache: projectSystemCache,
unconfiguredProject: null,
projectServices: projectServices,
projectId: projectName));
}
