public void SerializeThenDeserialize_WithValidArguments_RoundTrips(IPackageReferenceContextInfo expectedResult)
{
IPackageReferenceContextInfo actualResult = SerializeThenDeserialize(IPackageReferenceContextInfoFormatter.Instance, expectedResult);
Assert.Equal(expectedResult.Identity, actualResult.Identity);
Assert.Equal(expectedResult.Framework, actualResult.Framework);
Assert.Equal(expectedResult.AllowedVersions, actualResult.AllowedVersions);
Assert.Equal(expectedResult.IsAutoReferenced, actualResult.IsAutoReferenced);
Assert.Equal(expectedResult.IsUserInstalled, actualResult.IsUserInstalled);
Assert.Equal(expectedResult.IsDevelopmentDependency, actualResult.IsDevelopmentDependency);
}
private static void CheckPackageReferencesContextInfoAreEqual(IPackageReferenceContextInfo packageA, IPackageReferenceContextInfo packageB)
{
Assert.NotNull(packageA);
Assert.NotNull(packageB);
Assert.Equal(packageA.Identity, packageB.Identity);
Assert.Equal(packageA.Framework, packageB.Framework);
Assert.Equal(packageA.AllowedVersions, packageB.AllowedVersions);
Assert.Equal(packageA.IsAutoReferenced, packageB.IsAutoReferenced);
Assert.Equal(packageA.IsUserInstalled, packageB.IsUserInstalled);
Assert.Equal(packageA.IsDevelopmentDependency, packageB.IsDevelopmentDependency);
}
public async Task GetInstalledPackagesAsync_WhenProjectReturnsNullPackageReference_NullIsRemoved()
{
const string projectName = "a";
string projectId = Guid.NewGuid().ToString();
using (TestDirectory testDirectory = TestDirectory.Create())
{
Initialize();
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);
var packageReference = new PackageReference(
new PackageIdentity(id: "b", NuGetVersion.Parse("1.0.0")),
targetFramework);
project.InstalledPackageReferences = Task.FromResult <IEnumerable <PackageReference> >(new[]
{
null,
packageReference
});
_solutionManager.NuGetProjects.Add(project);
var telemetrySession = new Mock <ITelemetrySession>();
var telemetryEvents = new ConcurrentQueue <TelemetryEvent>();
telemetrySession
.Setup(x => x.PostEvent(It.IsAny <TelemetryEvent>()))
.Callback <TelemetryEvent>(x => telemetryEvents.Enqueue(x));
TelemetryActivity.NuGetTelemetryService = new NuGetVSTelemetryService(telemetrySession.Object);
IReadOnlyCollection <IPackageReferenceContextInfo> packages = await _projectManager.GetInstalledPackagesAsync(
new[] { projectId },
CancellationToken.None);
Assert.Equal(1, packages.Count);
IPackageReferenceContextInfo expected = PackageReferenceContextInfo.Create(packageReference);
IPackageReferenceContextInfo actual = packages.Single();
Assert.Equal(expected.AllowedVersions, actual.AllowedVersions);
Assert.Equal(expected.Framework, actual.Framework);
Assert.Equal(expected.Identity, actual.Identity);
Assert.Equal(expected.IsAutoReferenced, actual.IsAutoReferenced);
Assert.Equal(expected.IsDevelopmentDependency, actual.IsDevelopmentDependency);
Assert.Equal(expected.IsUserInstalled, actual.IsUserInstalled);
Assert.Equal(1, telemetryEvents.Count);
}
}
private static TransitivePackageReferenceContextInfo Create(IPackageReferenceContextInfo packageReference)
{
if (packageReference == null)
{
throw new ArgumentNullException(nameof(packageReference));
}
var tranPkgRefCtxInfo = new TransitivePackageReferenceContextInfo(packageReference.Identity, packageReference.Framework)
{
IsAutoReferenced = packageReference.IsAutoReferenced,
AllowedVersions = packageReference.AllowedVersions,
IsUserInstalled = packageReference.IsUserInstalled,
IsDevelopmentDependency = packageReference.IsDevelopmentDependency,
};
return(tranPkgRefCtxInfo);
}
public void SerializeThenDeserialize_WithValidArguments_RoundTrips(InstalledAndTransitivePackages expectedResult)
{
IInstalledAndTransitivePackages actualResult = SerializeThenDeserialize(IInstalledAndTransitivePackagesFormatter.Instance, expectedResult);
Assert.Equal(actualResult.InstalledPackages.Count, expectedResult.InstalledPackages.Count);
Assert.Equal(actualResult.TransitivePackages.Count, expectedResult.TransitivePackages.Count);
foreach (IPackageReferenceContextInfo expectedPackage in expectedResult.InstalledPackages)
{
IPackageReferenceContextInfo actualPackage = actualResult.InstalledPackages.FirstOrDefault(p => p.Identity.Equals(expectedPackage.Identity));
CheckPackageReferencesContextInfoAreEqual(actualPackage, expectedPackage);
}
foreach (IPackageReferenceContextInfo expectedPackage in expectedResult.TransitivePackages)
{
IPackageReferenceContextInfo actualPackage = actualResult.TransitivePackages.FirstOrDefault(p => p.Identity.Equals(expectedPackage.Identity));
CheckPackageReferencesContextInfoAreEqual(actualPackage, expectedPackage);
}
}
private static Tuple <string, string> CreatePackageTuple(IPackageReferenceContextInfo pkg)
{
PackageIdentity package = pkg.Identity;
return(Tuple.Create(package.Id, package.Version == null ? string.Empty : package.Version.ToNormalizedString()));
}
