private static void AssertFrameworkAssemblies(FrameworkAssemblyReference expected, FrameworkAssemblyReference actual)
{
Assert.Equal(expected.AssemblyName, actual.AssemblyName);
var actualSupportedFrameworks = expected.SupportedFrameworks.ToList();
var expectedSupportedFrameworks = expected.SupportedFrameworks.ToList();
for (int i = 0; i < expectedSupportedFrameworks.Count; i++)
{
Assert.Equal(expectedSupportedFrameworks[i], actualSupportedFrameworks[i]);
}
}
public void AddPackageReferenceWithAnyNonCompatibleFrameworkReferenceDoesThrow()
{
// Arrange
var mockProjectSystem = new Mock<MockProjectSystem>() { CallBase = true };
var localRepository = new MockPackageRepository();
var sourceRepository = new MockPackageRepository();
var projectManager = new ProjectManager(sourceRepository, new DefaultPackagePathResolver(mockProjectSystem.Object), mockProjectSystem.Object, localRepository);
mockProjectSystem.Setup(m => m.TargetFramework).Returns(VersionUtility.ParseFrameworkName("net20"));
var mockPackage = new Mock<IPackage>();
mockPackage.Setup(m => m.Id).Returns("A");
mockPackage.Setup(m => m.Version).Returns(new SemanticVersion("1.0"));
mockPackage.Setup(m => m.Listed).Returns(true);
var frameworkReference = new FrameworkAssemblyReference("System.Web", new[] { VersionUtility.ParseFrameworkName("net50") });
mockPackage.Setup(m => m.FrameworkAssemblies).Returns(new[] { frameworkReference });
sourceRepository.AddPackage(mockPackage.Object);
// Act & Assert
ExceptionAssert.Throws<InvalidOperationException>(
() => projectManager.AddPackageReference("A"));
Assert.False(localRepository.Exists(mockPackage.Object));
}
public static void AddDependencyGroups(IEnumerable <LibraryDependency> dependencies, NuGetFramework framework, PackageBuilder builder)
{
ISet <PackageDependency> packageDependencies = new HashSet <PackageDependency>();
foreach (var dependency in dependencies)
{
LibraryIncludeFlags effectiveInclude = dependency.IncludeType & ~dependency.SuppressParent;
if (dependency.IncludeType == LibraryIncludeFlags.None || dependency.SuppressParent == LibraryIncludeFlags.All)
{
continue;
}
if (dependency.LibraryRange.TypeConstraint == LibraryDependencyTarget.Reference)
{
var reference = builder.FrameworkReferences.FirstOrDefault(r => r.AssemblyName == dependency.Name);
if (reference == null)
{
builder.FrameworkReferences.Add(new FrameworkAssemblyReference(dependency.Name, new NuGetFramework [] { framework }));
}
else
{
if (!reference.SupportedFrameworks.Contains(framework))
{
// Add another framework reference by replacing the existing reference
var newReference = new FrameworkAssemblyReference(reference.AssemblyName, reference.SupportedFrameworks.Concat(new NuGetFramework[] { framework }));
int index = builder.FrameworkReferences.IndexOf(reference);
builder.FrameworkReferences.Remove(reference);
builder.FrameworkReferences.Insert(index, newReference);
}
}
}
else
{
List <string> includes = new List <string>();
List <string> excludes = new List <string>();
if (effectiveInclude == LibraryIncludeFlags.All)
{
includes.Add(LibraryIncludeFlags.All.ToString());
}
else if ((effectiveInclude & LibraryIncludeFlags.ContentFiles) == LibraryIncludeFlags.ContentFiles)
{
includes.AddRange(effectiveInclude.ToString().Split(new char[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries));
}
else
{
if ((LibraryIncludeFlagUtils.NoContent & ~effectiveInclude) != LibraryIncludeFlags.None)
{
excludes.AddRange((LibraryIncludeFlagUtils.NoContent & ~effectiveInclude).ToString().Split(new char[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries));
}
}
VersionRange version = dependency.LibraryRange.VersionRange;
if (!version.HasLowerBound && !version.HasUpperBound)
{
version = new VersionRange(builder.Version);
}
packageDependencies.Add(new PackageDependency(dependency.Name, version, includes, excludes));
}
}
var dependencyGroup = builder.DependencyGroups.FirstOrDefault(r => r.TargetFramework.Equals(framework));
if (dependencyGroup != null)
{
var existingDependencies = new HashSet <PackageDependency>(dependencyGroup.Packages);
foreach (var packageDependency in packageDependencies)
{
PackCommandRunner.AddPackageDependency(packageDependency, existingDependencies);
}
var newDependencyGroup = new PackageDependencyGroup(framework, existingDependencies);
builder.DependencyGroups.Remove(dependencyGroup);
builder.DependencyGroups.Add(newDependencyGroup);
}
else
{
builder.DependencyGroups.Add(new PackageDependencyGroup(framework, packageDependencies));
}
}
public AzureFrameworkAssemblyReference(FrameworkAssemblyReference reference)
{
AssemblyName = reference.AssemblyName;
SupportedFrameworks = reference.SupportedFrameworks
.Select(x => new AzureFrameworkName(x)).ToList();
}
private JToken WriteFrameworkAssemblyReference(FrameworkAssemblyReference item)
{
return(JToken.FromObject(item.AssemblyName));
}
public void AddPackageReferenceWithAnyNonCompatibleFrameworkReferenceThrowsAndPackageIsNotReferenced()
{
// Arrange
var mockProjectSystem = new Mock<MockProjectSystem>() { CallBase = true };
var localRepository = new MockPackageRepository();
var sourceRepository = new MockPackageRepository();
var projectManager = new ProjectManager(sourceRepository, new DefaultPackagePathResolver(mockProjectSystem.Object), mockProjectSystem.Object, localRepository);
mockProjectSystem.Setup(m => m.TargetFramework).Returns(new FrameworkName(".NETFramework", new Version("2.0")));
var mockPackage = new Mock<IPackage>();
mockPackage.Setup(m => m.Id).Returns("A");
mockPackage.Setup(m => m.Version).Returns(new Version("1.0"));
var frameworkReference = new FrameworkAssemblyReference("System.Web", new[] { new FrameworkName(".NETFramework", new Version("5.0")) });
mockPackage.Setup(m => m.FrameworkAssemblies).Returns(new[] { frameworkReference });
sourceRepository.AddPackage(mockPackage.Object);
// Act & Assert
ExceptionAssert.Throws<InvalidOperationException>(() => projectManager.AddPackageReference("A"), "Unable to find framework assemblies that are compatible with the target framework '.NETFramework,Version=v2.0'.");
Assert.IsFalse(localRepository.Exists(mockPackage.Object));
}
