private static ProjectAction CreateProjectAction(ResolvedAction resolvedAction)
{
List <ImplicitProjectAction>?implicitActions = null;
if (resolvedAction.Action is BuildIntegratedProjectAction buildIntegratedAction)
{
implicitActions = new List <ImplicitProjectAction>();
foreach (NuGetProjectAction buildAction in buildIntegratedAction.GetProjectActions())
{
var implicitAction = new ImplicitProjectAction(
CreateProjectActionId(),
buildAction.PackageIdentity,
buildAction.NuGetProjectActionType);
implicitActions.Add(implicitAction);
}
}
string projectId = resolvedAction.Project.GetMetadata <string>(NuGetProjectMetadataKeys.ProjectId);
var projectAction = new ProjectAction(
CreateProjectActionId(),
projectId,
resolvedAction.Action.PackageIdentity,
resolvedAction.Action.NuGetProjectActionType,
implicitActions);
return(projectAction);
}
public void SerializeThenDeserialize_WithValidArguments_RoundTrips(ImplicitProjectAction expectedResult)
{
ImplicitProjectAction?actualResult = SerializeThenDeserialize(ImplicitProjectActionFormatter.Instance, expectedResult);
Assert.NotNull(actualResult);
Assert.Equal(expectedResult, actualResult);
}
public void Equals_WithImplicitProjectAction_WhenArgumentIsDifferentImplicitProjectAction_ReturnsFalse()
{
var otherAction = new ImplicitProjectAction(
id: "b",
new PackageIdentity("c", NuGetVersion.Parse("2.3.4")),
NuGetProjectActionType.Install);
Assert.False(Action.Equals(other: otherAction));
}
public void Equals_WithObject_WhenArgumentIsEqualImplicitProjectAction_ReturnsTrue()
{
var otherAction = new ImplicitProjectAction(
Action.Id,
Action.PackageIdentity,
Action.ProjectActionType);
Assert.True(Action.Equals(obj: otherAction));
}
public void Constructor_WhenArgumentsAreValid_InitializesMembers()
{
const NuGetProjectActionType projectActionType = NuGetProjectActionType.Install;
var action = new ImplicitProjectAction(Id, PackageIdentity, projectActionType);
Assert.Equal(Id, action.Id);
Assert.Equal(PackageIdentity, action.PackageIdentity);
Assert.Equal(projectActionType, action.ProjectActionType);
}
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 ValueTask <IReadOnlyList <ProjectAction> > GetInstallActionsAsync(
IReadOnlyCollection <string> projectIds,
PackageIdentity packageIdentity,
VersionConstraints versionConstraints,
bool includePrelease,
DependencyBehavior dependencyBehavior,
IReadOnlyList <string> packageSourceNames,
CancellationToken cancellationToken)
{
Assumes.NotNullOrEmpty(projectIds);
Assumes.NotNull(packageIdentity);
Assumes.NotNullOrEmpty(packageSourceNames);
Assumes.Null(_state.PackageIdentity);
Assumes.True(_state.ResolvedActions.Count == 0);
Assumes.NotNull(_state.SourceCacheContext);
cancellationToken.ThrowIfCancellationRequested();
return(await CatchAndRethrowExceptionAsync(async() =>
{
_state.PackageIdentity = packageIdentity;
IReadOnlyList <SourceRepository> sourceRepositories = await GetSourceRepositoriesAsync(
packageSourceNames,
cancellationToken);
Assumes.NotNullOrEmpty(sourceRepositories);
INuGetProjectContext projectContext = await ServiceLocator.GetInstanceAsync <INuGetProjectContext>();
IReadOnlyList <NuGetProject> projects = await GetProjectsAsync(projectIds, cancellationToken);
var resolutionContext = new ResolutionContext(
dependencyBehavior,
includePrelease,
includeUnlisted: false,
versionConstraints,
new GatherCache(),
_state.SourceCacheContext);
NuGetPackageManager packageManager = await _sharedState.PackageManager.GetValueAsync(cancellationToken);
IEnumerable <ResolvedAction> resolvedActions = await packageManager.PreviewProjectsInstallPackageAsync(
projects,
_state.PackageIdentity,
resolutionContext,
projectContext,
sourceRepositories,
cancellationToken);
var projectActions = new List <ProjectAction>();
foreach (ResolvedAction resolvedAction in resolvedActions)
{
List <ImplicitProjectAction>?implicitActions = null;
if (resolvedAction.Action is BuildIntegratedProjectAction buildIntegratedAction)
{
implicitActions = new List <ImplicitProjectAction>();
foreach (NuGetProjectAction?buildAction in buildIntegratedAction.GetProjectActions())
{
var implicitAction = new ImplicitProjectAction(
CreateProjectActionId(),
buildAction.PackageIdentity,
buildAction.NuGetProjectActionType);
implicitActions.Add(implicitAction);
}
}
string projectId = resolvedAction.Project.GetMetadata <string>(NuGetProjectMetadataKeys.ProjectId);
var projectAction = new ProjectAction(
CreateProjectActionId(),
projectId,
resolvedAction.Action.PackageIdentity,
resolvedAction.Action.NuGetProjectActionType,
implicitActions);
_state.ResolvedActions[projectAction.Id] = resolvedAction;
projectActions.Add(projectAction);
}
return projectActions;
}));
}
