private static IEnumerable <NugetDefinition> CastDependencies(T_Result input, PackageDependencySet compatibleFrameworkDependencies)
{
return(compatibleFrameworkDependencies
.Dependencies
.Select(a =>
{
if (!input.ContainsKey(a.Id))
{
return null;
}
var version = input[a.Id].Select(b => b.Key).First(b => a.VersionSpec.Satisfies(b));
PackageDependencySet dep = default(PackageDependencySet);
if (input[a.Id][version].Count() == 1 && compatibleFrameworkDependencies.TargetFramework == null)
{
dep = input[a.Id][version].First();
}
else
{
dep = input[a.Id][version].FirstOrDefault(b => b.TargetFramework == compatibleFrameworkDependencies.TargetFramework);
}
return new NugetDefinition()
{
Id = a.Id,
CurrentVersion = version,
Dependencies = dep
};
}).Where(a => a != null));
}
public void DependenciesAreFilteredByTargetFramework6()
{
// Arrange
var dependencySets = new PackageDependencySet[] {
new PackageDependencySet(
new FrameworkName("Silverlight, Version=2.0"),
new [] { new PackageDependency("A"), new PackageDependency("B") }
),
new PackageDependencySet(
new FrameworkName("Silverlight, Version=3.0"),
new [] { new PackageDependency("B"), new PackageDependency("C") }
),
new PackageDependencySet(
new FrameworkName(".NETFramework, Version=4.0"),
new PackageDependency[0]
),
};
var package = new Mock <IPackage>();
package.Setup(p => p.Id).Returns("P");
package.Setup(p => p.Version).Returns(new SemanticVersion("1.0"));
package.Setup(p => p.DependencySets).Returns(dependencySets);
var item = CreatePackageItem(package.Object);
item.TargetFramework = new FrameworkName(".NETFramework, Version=4.0");
// Act
var dependencies = item.Dependencies.ToList();
// Assert
Assert.Equal(0, dependencies.Count);
}
static void CreatePackage(PackageInfo package)
{
var packageBuilder = new PackageBuilder()
{
Id = package.Id,
Version = package.Version,
Description = "Some test package"
};
packageBuilder.Authors.Add(".NET Foundation");
string assemblySourcePath = GetAssemblyFullPath(package.FullName);
packageBuilder.Files.Add(new PhysicalPackageFile()
{
SourcePath = assemblySourcePath,
TargetPath = @"lib\" + Path.GetFileName(assemblySourcePath)
});
var set = new PackageDependencySet(VersionUtility.DefaultTargetFramework,
package.Dependencies.Select(dependency => new PackageDependency(dependency.Id, dependency.VersionSpec)));
packageBuilder.DependencySets.Add(set);
using (var stream = File.Create(GetPackageFileFullPath(package)))
{
packageBuilder.Save(stream);
}
}
private static bool TargetFrameworkMatch(FrameworkName targetFramework, PackageDependencySet set)
{
if (targetFramework == null)
{
return(true);
}
return(set.TargetFramework == targetFramework);
}
private static PackageDependencyGroup GetVisualStudioUIPackageDependencySet(PackageDependencySet dependencySet)
{
IEnumerable<NuGet.Packaging.Core.PackageDependency> visualStudioUIPackageDependencies = dependencySet.Dependencies.Select(d => GetVisualStudioUIPackageDependency(d));
NuGetFramework fxName = NuGetFramework.AnyFramework;
if (dependencySet.TargetFramework != null)
fxName = NuGetFramework.Parse(dependencySet.TargetFramework.FullName);
return new PackageDependencyGroup(fxName, visualStudioUIPackageDependencies);
}
private static string[] GetDependencies(bool isCore, PackageDependencySet coreDeps)
{
return(coreDeps.Dependencies
.Select(d => d.Id)
.Where(d => !(isCore && d.StartsWith("System.")))
.Where(d => !d.StartsWith("Microsoft.NETCore."))
.Where(d => d != "NETStandard.Library")
.ToArray());
}
public static JObject CreateDependencyGroup(PackageDependencySet set)
{
var value = new JObject();
AddProp(value, Properties.Type, Types.DependencyGroup);
AddProp(value, Properties.TargetFramework, set.TargetFramework == null ? null : VersionUtility.GetShortFrameworkName(set.TargetFramework));
AddProp(value, Properties.Dependencies, set.Dependencies.Select(d => CreateDependency(d)));
return(value);
}
private static PackageDependencyGroup GetVisualStudioUIPackageDependencySet(PackageDependencySet dependencySet)
{
var visualStudioUIPackageDependencies = dependencySet.Dependencies.Select(d => GetVisualStudioUIPackageDependency(d));
var fxName = NuGetFramework.AnyFramework;
if (dependencySet.TargetFramework != null)
{
fxName = NuGetFramework.Parse(dependencySet.TargetFramework.FullName);
}
return new PackageDependencyGroup(fxName, visualStudioUIPackageDependencies);
}
private IEnumerable <string> GetReferencedPackageNames(IPackage package)
{
PackageDependencySet dependencySet = package.DependencySets.SingleOrDefault(x => x.TargetFramework == null || x.TargetFramework == mPackageManager.TargetFramework);
if (dependencySet == null)
{
return(Enumerable.Empty <string>());
}
return(dependencySet.Dependencies.Select(x => x.Id));
}
protected virtual void AddDependencies(PackageBuilder builder, IPackageDescriptor descriptor)
{
if (descriptor.Dependencies.Count == 0)
{
return;
}
var dependencySet = new PackageDependencySet(VersionUtility.DefaultTargetFramework, descriptor.Dependencies);
builder.DependencySets.Add(dependencySet);
}
private NuGetFramework GetNuGetFramework(PackageDependencySet dependencySet)
{
NuGetFramework fxName = NuGetFramework.AnyFramework;
if (dependencySet.TargetFramework != null)
{
fxName = NuGetFramework.Parse(dependencySet.TargetFramework.FullName);
}
return(fxName);
}
private static UIPackageDependencySet GetVisualStudioUIPackageDependencySet(PackageDependencySet dependencySet)
{
IEnumerable <NuGet.PackagingCore.PackageDependency> visualStudioUIPackageDependencies = dependencySet.Dependencies.Select(d => GetVisualStudioUIPackageDependency(d));
NuGetFramework fxName = NuGetFramework.AnyFramework;
if (dependencySet.TargetFramework != null)
{
fxName = NuGetFramework.Parse(dependencySet.TargetFramework.FullName);
}
return(new UIPackageDependencySet(fxName, visualStudioUIPackageDependencies));
}
public static IEnumerable<string> Flatten(PackageDependencySet set)
{
var shortFrameworkName = set.TargetFramework == null ? null : VersionUtility.GetShortFrameworkName(set.TargetFramework);
if (shortFrameworkName != null && set.Dependencies.Count == 0)
{
return new[] {"::" + shortFrameworkName};
}
return set.Dependencies.Select(d => string.Format("{0}:{1}:{2}", d.Id, d.VersionSpec, shortFrameworkName));
}
public static IEnumerable <string> Flatten(PackageDependencySet set)
{
var shortFrameworkName = set.TargetFramework == null ? null : VersionUtility.GetShortFrameworkName(set.TargetFramework);
if (shortFrameworkName != null && set.Dependencies.Count == 0)
{
return(new[] { "::" + shortFrameworkName });
}
return(set.Dependencies.Select(d => string.Format("{0}:{1}:{2}", d.Id, d.VersionSpec, shortFrameworkName)));
}
private static PackageDependencySet TargetDependency(PackageDependencySet packageDependencySet, FrameworkName targetFramework)
{
if (packageDependencySet.TargetFramework == null && packageDependencySet.Dependencies.Count > 0)
{
return(new PackageDependencySet(targetFramework, packageDependencySet.Dependencies));
}
else
{
return(packageDependencySet);
}
}
private static PackageDependencyGroup GetVisualStudioUIPackageDependencySet(PackageDependencySet dependencySet)
{
var visualStudioUIPackageDependencies = dependencySet.Dependencies.Select(d => GetVisualStudioUIPackageDependency(d));
var fxName = NuGetFramework.AnyFramework;
if (dependencySet.TargetFramework != null)
{
fxName = NuGetFramework.Parse(dependencySet.TargetFramework.FullName);
}
return(new PackageDependencyGroup(fxName, visualStudioUIPackageDependencies));
}
public static string CreateTestPackage(
string packageId,
string version,
string path,
List <NuGetFramework> frameworks,
List <PackageDependencyGroup> dependencies)
{
var packageBuilder = new PackageBuilder
{
Id = packageId,
Version = new SemanticVersion(version)
};
packageBuilder.Description = string.Format(
CultureInfo.InvariantCulture,
"desc of {0} {1}",
packageId, version);
foreach (var framework in frameworks)
{
var libPath = string.Format(
CultureInfo.InvariantCulture,
"lib/{0}/file.dll",
framework.GetShortFolderName());
packageBuilder.Files.Add(CreatePackageFile(libPath));
}
packageBuilder.Authors.Add("test author");
foreach (var group in dependencies)
{
var set = new PackageDependencySet(
null,
group.Packages.Select(package =>
new PackageDependency(package.Id,
VersionUtility.ParseVersionSpec(package.VersionRange.ToNormalizedString()))));
packageBuilder.DependencySets.Add(set);
}
var packageFileName = string.Format("{0}.{1}.nupkg", packageId, version);
var packageFileFullPath = Path.Combine(path, packageFileName);
Directory.CreateDirectory(path);
using (var fileStream = File.Create(packageFileFullPath))
{
packageBuilder.Save(fileStream);
}
return(packageFileFullPath);
}
internal void ResolveProjectDependency(ProjectReference reference, T_Result input, Action <NugetReferenceResult> report)
{
if (!input.ContainsKey(reference.Id))
{
return;
}
SemanticVersion compatibleVersion = default(SemanticVersion);
if (reference.Version == null)
// Version is not specified -> just take the first one
{
compatibleVersion = input[reference.Id].First().Key;
}
else
{
compatibleVersion = reference.Version;
}
if (!input[reference.Id].ContainsKey(compatibleVersion))
{
Log.Error("Target package {package} - {version} is not installed. The nuget map will be incomplete. Try to build your solution and try again.", reference.Id, compatibleVersion);
return;
}
IEnumerable <PackageDependencySet> currentDependencies = input[reference.Id][compatibleVersion];
PackageDependencySet compatibleFrameworkDependencies = default(PackageDependencySet);
if (currentDependencies.Count() == 1 && currentDependencies.First().TargetFramework == null)
// there are not specified target frameworks -> just use all available
{
compatibleFrameworkDependencies = currentDependencies.First();
}
else
{
compatibleFrameworkDependencies = FindCompatibleFramework(currentDependencies, reference.Framework);
}
if (compatibleFrameworkDependencies == null)
{
return;
}
IEnumerable <NugetDefinition> castDependencies = CastDependencies(input, compatibleFrameworkDependencies);
ReportDependencies(castDependencies, input, report, reference.ToString());
}
public void InstallPackageUsesProjectTargetFramework()
{
// Arrange
var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>().Object;
var sourceRepository = new MockPackageRepository();
var projectSystem = new MockProjectSystem(new FrameworkName(".NETFramework, Version=4.5"));
var pathResolver = new DefaultPackagePathResolver(projectSystem);
var projectManager = new ProjectManager(localRepository, pathResolver, projectSystem, new MockPackageRepository());
var packageManager = new VsPackageManager(
TestUtils.GetSolutionManager(),
sourceRepository,
new Mock<IFileSystemProvider>().Object,
projectSystem,
localRepository,
new Mock<IRecentPackageRepository>().Object,
new Mock<VsPackageInstallerEvents>().Object);
var dependencySets = new PackageDependencySet[] {
new PackageDependencySet(
new FrameworkName(".NETFramework, Version=4.5"),
new [] { new PackageDependency("B") }),
new PackageDependencySet(
new FrameworkName(".NETFramework, Version=4.0"),
new [] { new PackageDependency("C") })
};
var package = PackageUtility.CreatePackageWithDependencySets(
"foo",
"1.0",
new[] { "hello" },
dependencySets: dependencySets);
var packageB = PackageUtility.CreatePackage("B", "2.0", new[] { "good morning" });
var packageC = PackageUtility.CreatePackage("C", "2.0", new[] { "good morning" });
sourceRepository.AddPackage(package);
sourceRepository.AddPackage(packageB);
sourceRepository.AddPackage(packageC);
// Act
packageManager.InstallPackage(projectManager, "foo", new SemanticVersion("1.0"), ignoreDependencies: false, allowPrereleaseVersions: false, logger: NullLogger.Instance);
// Assert
Assert.True(packageManager.LocalRepository.Exists(package));
Assert.True(packageManager.LocalRepository.Exists(packageB));
Assert.False(packageManager.LocalRepository.Exists(packageC));
Assert.True(projectManager.LocalRepository.Exists(package));
Assert.True(projectManager.LocalRepository.Exists(packageB));
}
public override void Context()
{
base.Context();
var packageDependencies = new List <PackageDependency>
{
chocolateyPackageDependency
};
var packageDependencySet = new PackageDependencySet(new FrameworkName(".NETFramework, Version = 4.0"), packageDependencies);
package.Setup(p => p.DependencySets).Returns(
new List <PackageDependencySet>
{
packageDependencySet
});
}
public override void Context()
{
base.Context();
var packageDependencies = new List <PackageDependency>
{
packageDependencyWithNoVersion
};
var packageDependencySet = new PackageDependencySet(null, packageDependencies);
package.Setup(p => p.DependencySets).Returns(
new List <PackageDependencySet>
{
packageDependencySet
});
}
public static PackageBuilder CreateExecutablePackage(string path, Manifest manifest, PackageConfiguration configuration, out bool updateDependencies)
{
if (string.IsNullOrEmpty(path) || !File.Exists(path))
{
throw new ArgumentException("Invalid workflow file path.", "path");
}
var packageBuilder = new PackageBuilder();
var basePath = Path.GetDirectoryName(path) + "\\";
packageBuilder.Populate(manifest.Metadata);
packageBuilder.Tags.Add(NuGet.Constants.BonsaiDirectory);
packageBuilder.Tags.Add(NuGet.Constants.GalleryDirectory);
var files = manifest.Files ?? GetContentFiles(basePath);
packageBuilder.PopulateFiles(basePath, files);
var manifestDependencies = new Dictionary <string, PackageDependency>(StringComparer.OrdinalIgnoreCase);
foreach (var dependency in packageBuilder.DependencySets.Where(set => set.TargetFramework == null)
.SelectMany(set => set.Dependencies))
{
manifestDependencies.Add(dependency.Id, dependency);
}
updateDependencies = false;
var workflowFiles = packageBuilder.Files.Select(file => file as PhysicalPackageFile)
.Where(file => file != null && Path.GetExtension(file.SourcePath) == NuGet.Constants.BonsaiExtension)
.Select(file => file.SourcePath)
.ToArray();
var workflowDependencies = DependencyInspector.GetWorkflowPackageDependencies(workflowFiles, configuration).ToArray().Wait();
foreach (var dependency in workflowDependencies)
{
PackageDependency manifestDependency;
if (!manifestDependencies.TryGetValue(dependency.Id, out manifestDependency) ||
!DependencyEqualityComparer.Default.Equals(dependency, manifestDependency))
{
updateDependencies = true;
manifestDependencies[dependency.Id] = dependency;
}
}
var dependencySet = new PackageDependencySet(null, manifestDependencies.Values);
packageBuilder.DependencySets.Clear();
packageBuilder.DependencySets.Add(dependencySet);
return(packageBuilder);
}
public void InstallCommand_DependencyResolutionFailure()
{
var targetDir = ConfigurationManager.AppSettings["TargetDir"];
var nugetexe = Path.Combine(targetDir, "nuget.exe");
var tempPath = Path.GetTempPath();
var source = Path.Combine(tempPath, Guid.NewGuid().ToString());
var outputDirectory = Path.Combine(tempPath, Guid.NewGuid().ToString());
try
{
// Arrange
Util.CreateDirectory(source);
Util.CreateDirectory(outputDirectory);
var packageFileName = PackageCreater.CreatePackage(
"testPackage1", "1.1.0", source,
(builder) =>
{
var dependencySet = new PackageDependencySet(null,
new [] {
new PackageDependency(
"non_existing",
VersionUtility.ParseVersionSpec("1.1"))
});
builder.DependencySets.Add(dependencySet);
});
// Act
var args = String.Format(
CultureInfo.InvariantCulture,
"install testPackage1 -OutputDirectory {0} -Source {1}", outputDirectory, source);
var r = CommandRunner.Run(
nugetexe,
Directory.GetCurrentDirectory(),
args,
waitForExit: true);
// Assert
Assert.NotEqual(0, r.Item1);
Assert.Contains("Attempting to resolve dependency 'non_existing (≥ 1.1)'", r.Item2);
}
finally
{
// Cleanup
Util.DeleteDirectory(outputDirectory);
Util.DeleteDirectory(source);
}
}
internal void ResolveNugetDependency(NugetDefinition nugetDependency, T_Result input, Action <NugetReferenceResult> report)
{
if (!input.ContainsKey(nugetDependency.Id))
{
return;
}
SemanticVersion compatibleVersion = default(SemanticVersion);
if (input[nugetDependency.Id].ContainsKey(nugetDependency.CurrentVersion))
// Version was specified and packages folder contains the desired version
{
compatibleVersion = nugetDependency.CurrentVersion;
}
else
// Search for compatible framework version. Since target and installed version can differ from each other.
{
compatibleVersion = input[nugetDependency.Id]
.Where(a => a.Key.Version.Major == nugetDependency.CurrentVersion.Version.Major)
.Select(a => a.Key)
.OrderByDescending(a => a.Version)
.FirstOrDefault();
}
IEnumerable <PackageDependencySet> currentDependencies = input[nugetDependency.Id][compatibleVersion];
PackageDependencySet compatibleFrameworkDependencies = default(PackageDependencySet);
if (currentDependencies.Count() == 1 && currentDependencies.First().TargetFramework == null ||
nugetDependency.Framework == null)
// there are not specified target frameworks -> just use all available
{
compatibleFrameworkDependencies = currentDependencies.First();
}
else
{
compatibleFrameworkDependencies = FindCompatibleFramework(currentDependencies, nugetDependency.Framework);
}
if (compatibleFrameworkDependencies == null)
{
return;
}
IEnumerable <NugetDefinition> castDependencies = CastDependencies(input, compatibleFrameworkDependencies);
ReportDependencies(castDependencies, input, report, nugetDependency.ToString());
}
/// <summary>
/// Inserts a dependency set into the packagebuilder object, based on a dictionary
/// containing Id/version pairs (Newtonsoft.json, 5.0.6 for example).
/// </summary>
/// <param name="builder"></param>
/// <param name="packages"></param>
private void AddNugetDependencies(NuGet.PackageBuilder builder, Dictionary <string, string> packages)
{
//add dependencies
List <PackageDependency> dependencies = new List <PackageDependency>();
foreach (var package in packages)
{
dependencies.Add(new PackageDependency(package.Key, new VersionSpec {
MinVersion = new SemanticVersion(package.Value), IsMinInclusive = true
}));
}
var set = new PackageDependencySet(null, dependencies);
builder.DependencySets.Add(set);
}
private static IEnumerable <string> ConvertDependencySetToStrings(PackageDependencySet dependencySet)
{
if (dependencySet.Dependencies.Count == 0)
{
if (dependencySet.TargetFramework != null)
{
return new[] { String.Format("::{0}", VersionUtility.GetShortFrameworkName(dependencySet.TargetFramework)) }
}
;
}
else
{
return(dependencySet.Dependencies.Select(dependency => ConvertDependency(dependency, dependencySet.TargetFramework)));
}
return(new string[0]);
}
private IEnumerable <string> ConvertDependencySetToStrings(PackageDependencySet dependencySet)
{
if (dependencySet.Dependencies.Count == 0)
{
if (dependencySet.TargetFramework != null)
{
// if this Dependency set is empty, we still need to send down one string of the form "::<target framework>",
// so that the client can reconstruct an empty group.
return(new string[] { String.Format("::{0}", VersionUtility.GetShortFrameworkName(dependencySet.TargetFramework)) });
}
}
else
{
return(dependencySet.Dependencies.Select(dependency => ConvertDependency(dependency, dependencySet.TargetFramework)));
}
return(new string[0]);
}
public void PackageItemReturnsAllDependenciesWhenTargetFrameworkIsNull()
{
// Arrange
var dependencySets = new PackageDependencySet[] {
new PackageDependencySet(
new FrameworkName("Silverlight, Version=2.0"),
new [] { new PackageDependency("A"), new PackageDependency("B") }
),
new PackageDependencySet(
new FrameworkName("Silverlight, Version=3.0"),
new [] { new PackageDependency("C"), new PackageDependency("D") }
),
new PackageDependencySet(
new FrameworkName(".NETFramework, Version=4.0"),
new [] { new PackageDependency("E"), new PackageDependency("F") }
),
};
var package = new Mock <IPackage>();
package.Setup(p => p.Id).Returns("P");
package.Setup(p => p.Version).Returns(new SemanticVersion("1.0"));
package.Setup(p => p.DependencySets).Returns(dependencySets);
var item = CreatePackageItem(package.Object);
item.TargetFramework = null;
// Act
var dependencies = item.Dependencies.ToList();
// Assert
Assert.Equal(6, dependencies.Count);
Assert.Equal("A", dependencies[0].Id);
Assert.Equal("B", dependencies[1].Id);
Assert.Equal("C", dependencies[2].Id);
Assert.Equal("D", dependencies[3].Id);
Assert.Equal("E", dependencies[4].Id);
Assert.Equal("F", dependencies[5].Id);
}
public static Stream CreateSimplePackageStream(string id, string version = "1.0")
{
var packageBuilder = new PackageBuilder
{
Id = id,
Version = SemanticVersion.Parse(version),
Description = "Test description",
};
var dependencySet = new PackageDependencySet(VersionUtility.DefaultTargetFramework,
new PackageDependency[] {
new PackageDependency("Foo")
});
packageBuilder.DependencySets.Add(dependencySet);
packageBuilder.Authors.Add("foo");
var memoryStream = new MemoryStream();
packageBuilder.Save(memoryStream);
memoryStream.Seek(0, SeekOrigin.Begin);
return(memoryStream);
}
public void InstallPackageCmdletOnlyOpenReadmeFileFromTheRootPackage()
{
// Arrange
// A --> B
var packageA = new Mock <IPackage>();
packageA.Setup(p => p.Id).Returns("A");
packageA.Setup(p => p.Version).Returns(new SemanticVersion("1.0"));
var depSet = new PackageDependencySet(null, new[] { new PackageDependency("B") });
packageA.Setup(p => p.DependencySets).Returns(new[] { depSet });
packageA.Setup(p => p.Listed).Returns(true);
var readme = new Mock <IPackageFile>();
readme.Setup(f => f.Path).Returns("readMe.txt");
readme.Setup(f => f.GetStream()).Returns(new MemoryStream());
packageA.Setup(p => p.GetFiles()).Returns(new IPackageFile[] { readme.Object });
var packageB = new Mock <IPackage>();
packageB.Setup(p => p.Id).Returns("B");
packageB.Setup(p => p.Version).Returns(new SemanticVersion("1.0"));
var readmeB = new Mock <IPackageFile>();
readmeB.Setup(f => f.Path).Returns("readMe.txt");
readmeB.Setup(f => f.GetStream()).Returns(new MemoryStream());
packageB.Setup(p => p.GetFiles()).Returns(new IPackageFile[] { readmeB.Object });
var sharedRepository = new Mock <ISharedPackageRepository>(MockBehavior.Strict);
sharedRepository.Setup(s => s.GetPackages()).Returns(Enumerable.Empty <IPackage>().AsQueryable());
sharedRepository.Setup(s => s.AddPackage(packageA.Object));
sharedRepository.Setup(s => s.AddPackage(packageB.Object));
sharedRepository.Setup(s => s.IsReferenced("A", new SemanticVersion("1.0"))).Returns(true);
sharedRepository.Setup(s => s.IsReferenced("B", new SemanticVersion("1.0"))).Returns(true);
var packageRepository = new MockPackageRepository {
packageA.Object, packageB.Object
};
var recentPackageRepository = new Mock <IRecentPackageRepository>();
var packageManager = new VsPackageManager(
TestUtils.GetSolutionManagerWithProjects("foo"),
packageRepository,
new Mock <IFileSystemProvider>().Object,
new MockFileSystem(),
sharedRepository.Object,
recentPackageRepository.Object,
new VsPackageInstallerEvents());
var packageManagerFactory = new Mock <IVsPackageManagerFactory>(MockBehavior.Strict);
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager);
var fileOperations = new Mock <IVsCommonOperations>();
// Act
var cmdlet = new InstallPackageCommand(
TestUtils.GetSolutionManager(),
packageManagerFactory.Object,
null,
new Mock <IVsPackageSourceProvider>().Object,
new Mock <IHttpClientEvents>().Object,
null,
fileOperations.Object);
cmdlet.Id = "A";
cmdlet.Execute();
// Assert
fileOperations.Verify(io => io.OpenFile(It.Is <string>(s => s.EndsWith("A.1.0\\readme.txt", StringComparison.OrdinalIgnoreCase))), Times.Once());
fileOperations.Verify(io => io.OpenFile(It.Is <string>(s => s.EndsWith("B.1.0\\readme.txt", StringComparison.OrdinalIgnoreCase))), Times.Never());
}
public void PackageItemReturnsAllDependenciesWhenTargetFrameworkIsNull()
{
// Arrange
var dependencySets = new PackageDependencySet[] {
new PackageDependencySet(
new FrameworkName("Silverlight, Version=2.0"),
new [] { new PackageDependency("A"), new PackageDependency("B") }
),
new PackageDependencySet(
new FrameworkName("Silverlight, Version=3.0"),
new [] { new PackageDependency("C"), new PackageDependency("D") }
),
new PackageDependencySet(
new FrameworkName(".NETFramework, Version=4.0"),
new [] { new PackageDependency("E"), new PackageDependency("F") }
),
};
var package = new Mock<IPackage>();
package.Setup(p => p.Id).Returns("P");
package.Setup(p => p.Version).Returns(new SemanticVersion("1.0"));
package.Setup(p => p.DependencySets).Returns(dependencySets);
var item = CreatePackageItem(package.Object);
item.TargetFramework = null;
// Act
var dependencies = item.Dependencies.ToList();
// Assert
Assert.Equal(6, dependencies.Count);
Assert.Equal("A", dependencies[0].Id);
Assert.Equal("B", dependencies[1].Id);
Assert.Equal("C", dependencies[2].Id);
Assert.Equal("D", dependencies[3].Id);
Assert.Equal("E", dependencies[4].Id);
Assert.Equal("F", dependencies[5].Id);
}
public void InstallCommand_DependencyResolutionFailure()
{
var targetDir = ConfigurationManager.AppSettings["TargetDir"];
var nugetexe = Path.Combine(targetDir, "nuget.exe");
var tempPath = Path.GetTempPath();
var source = Path.Combine(tempPath, Guid.NewGuid().ToString());
var outputDirectory = Path.Combine(tempPath, Guid.NewGuid().ToString());
try
{
// Arrange
Util.CreateDirectory(source);
Util.CreateDirectory(outputDirectory);
var packageFileName = PackageCreater.CreatePackage(
"testPackage1", "1.1.0", source,
(builder) =>
{
var dependencySet = new PackageDependencySet(null,
new [] {
new PackageDependency(
"non_existing",
VersionUtility.ParseVersionSpec("1.1"))
});
builder.DependencySets.Add(dependencySet);
});
// Act
var args = String.Format(
CultureInfo.InvariantCulture,
"install testPackage1 -OutputDirectory {0} -Source {1}", outputDirectory, source);
var r = CommandRunner.Run(
nugetexe,
Directory.GetCurrentDirectory(),
args,
waitForExit: true);
// Assert
Assert.NotEqual(0, r.Item1);
Assert.Contains("Attempting to resolve dependency 'non_existing (≥ 1.1)'", r.Item2);
}
finally
{
// Cleanup
Util.DeleteDirectory(outputDirectory);
Util.DeleteDirectory(source);
}
}
public void InstallPackageCmdletOnlyOpenReadmeFileFromTheRootPackage()
{
// Arrange
// A --> B
var packageA = new Mock <IPackage>();
packageA.Setup(p => p.Id).Returns("A");
packageA.Setup(p => p.Version).Returns(new SemanticVersion("1.0"));
var depSet = new PackageDependencySet(null, new[] { new PackageDependency("B") });
packageA.Setup(p => p.DependencySets).Returns(new[] { depSet });
packageA.Setup(p => p.Listed).Returns(true);
var readme = new Mock <IPackageFile>();
readme.Setup(f => f.Path).Returns("readMe.txt");
readme.Setup(f => f.GetStream()).Returns(new MemoryStream());
packageA.Setup(p => p.GetFiles()).Returns(new IPackageFile[] { readme.Object });
packageA.Setup(p => p.GetStream()).Returns(new MemoryStream());
var packageB = new Mock <IPackage>();
packageB.Setup(p => p.Id).Returns("B");
packageB.Setup(p => p.Version).Returns(new SemanticVersion("1.0"));
var readmeB = new Mock <IPackageFile>();
readmeB.Setup(f => f.Path).Returns("readMe.txt");
readmeB.Setup(f => f.GetStream()).Returns(new MemoryStream());
packageB.Setup(p => p.GetFiles()).Returns(new IPackageFile[] { readmeB.Object });
packageB.Setup(p => p.GetStream()).Returns(new MemoryStream());
var packageRepository = new MockPackageRepository {
packageA.Object, packageB.Object
};
var packageManager = new MockVsPackageManager2(
@"c:\solution",
packageRepository);
var packageManagerFactory = new Mock <IVsPackageManagerFactory>(MockBehavior.Strict);
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager);
var fileOperations = new Mock <IVsCommonOperations>();
// Act
var cmdlet = new InstallPackageCommand(
packageManager.SolutionManager,
packageManagerFactory.Object,
null,
new Mock <IVsPackageSourceProvider>().Object,
new Mock <IHttpClientEvents>().Object,
null,
fileOperations.Object,
new Mock <IDeleteOnRestartManager>().Object,
true);
cmdlet.Id = "A";
cmdlet.Execute();
// Assert
fileOperations.Verify(io => io.OpenFile(It.Is <string>(s => s.EndsWith("A.1.0\\readme.txt", StringComparison.OrdinalIgnoreCase))), Times.Once());
fileOperations.Verify(io => io.OpenFile(It.Is <string>(s => s.EndsWith("B.1.0\\readme.txt", StringComparison.OrdinalIgnoreCase))), Times.Never());
}
public void InstallPackageCmdletOnlyOpenReadmeFileFromTheRootPackage()
{
// Arrange
// A --> B
var packageA = new Mock<IPackage>();
packageA.Setup(p => p.Id).Returns("A");
packageA.Setup(p => p.Version).Returns(new SemanticVersion("1.0"));
var depSet = new PackageDependencySet(null, new[] { new PackageDependency("B") });
packageA.Setup(p => p.DependencySets).Returns(new[] { depSet });
packageA.Setup(p => p.Listed).Returns(true);
var readme = new Mock<IPackageFile>();
readme.Setup(f => f.Path).Returns("readMe.txt");
readme.Setup(f => f.GetStream()).Returns(new MemoryStream());
packageA.Setup(p => p.GetFiles()).Returns(new IPackageFile[] { readme.Object });
var packageB = new Mock<IPackage>();
packageB.Setup(p => p.Id).Returns("B");
packageB.Setup(p => p.Version).Returns(new SemanticVersion("1.0"));
var readmeB = new Mock<IPackageFile>();
readmeB.Setup(f => f.Path).Returns("readMe.txt");
readmeB.Setup(f => f.GetStream()).Returns(new MemoryStream());
packageB.Setup(p => p.GetFiles()).Returns(new IPackageFile[] { readmeB.Object });
var sharedRepository = new Mock<ISharedPackageRepository>(MockBehavior.Strict);
sharedRepository.Setup(s => s.GetPackages()).Returns(Enumerable.Empty<IPackage>().AsQueryable());
sharedRepository.Setup(s => s.AddPackage(packageA.Object));
sharedRepository.Setup(s => s.AddPackage(packageB.Object));
sharedRepository.Setup(s => s.IsReferenced("A", new SemanticVersion("1.0"))).Returns(true);
sharedRepository.Setup(s => s.IsReferenced("B", new SemanticVersion("1.0"))).Returns(true);
var packageRepository = new MockPackageRepository { packageA.Object, packageB.Object };
var packageManager = new VsPackageManager(
TestUtils.GetSolutionManagerWithProjects("foo"),
packageRepository,
new Mock<IFileSystemProvider>().Object,
new MockFileSystem(),
sharedRepository.Object,
new Mock<IDeleteOnRestartManager>().Object,
new VsPackageInstallerEvents());
var packageManagerFactory = new Mock<IVsPackageManagerFactory>(MockBehavior.Strict);
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager);
var fileOperations = new Mock<IVsCommonOperations>();
// Act
var cmdlet = new InstallPackageCommand(
TestUtils.GetSolutionManager(),
packageManagerFactory.Object,
null,
new Mock<IVsPackageSourceProvider>().Object,
new Mock<IHttpClientEvents>().Object,
null,
fileOperations.Object,
new Mock<IDeleteOnRestartManager>().Object);
cmdlet.Id = "A";
cmdlet.Execute();
// Assert
fileOperations.Verify(io => io.OpenFile(It.Is<string>(s => s.EndsWith("A.1.0\\readme.txt", StringComparison.OrdinalIgnoreCase))), Times.Once());
fileOperations.Verify(io => io.OpenFile(It.Is<string>(s => s.EndsWith("B.1.0\\readme.txt", StringComparison.OrdinalIgnoreCase))), Times.Never());
}
public void AddPackageReferenceDoNotIncludeDependencyPackageIfTargetFrameworkDoesNotMatch(string dependencyVersion)
{
// Arrange
var sourceRepository = new MockPackageRepository();
var projectSystem = new MockProjectSystem(new FrameworkName(".NETFramework", new Version("2.0")));
var projectManager = new ProjectManager(sourceRepository, new DefaultPackagePathResolver(projectSystem), projectSystem, new MockPackageRepository());
var dependency = new PackageDependency("B", null);
var dependencySet = new PackageDependencySet(
new FrameworkName(".NETFramework", new Version(dependencyVersion)),
new PackageDependency[] {dependency});
IPackage packageA = PackageUtility.CreatePackage("A", "1.0", content: new[] { "a.txt" });
Mock.Get(packageA).Setup(p => p.DependencySets).Returns(new [] {dependencySet});
IPackage packageB = PackageUtility.CreatePackage("B", "1.0", content: new[] { "b.txt" });
sourceRepository.AddPackage(packageB);
sourceRepository.AddPackage(packageA);
// Act
projectManager.AddPackageReference("A");
// Assert
Assert.True(projectManager.LocalRepository.Exists("A"));
Assert.False(projectManager.LocalRepository.Exists("B"));
Assert.True(projectSystem.FileExists("a.txt"));
Assert.False(projectSystem.FileExists("b.txt"));
}
public void ValidateDependenciesDoesNotThrowIfDependencyForAStableVersionIsStable()
{
// Arrange
var dependencies = new[] {
new PackageDependency("A", new VersionSpec(new SemanticVersion("1.0.0"))),
new PackageDependency("B", new VersionSpec { MinVersion = new SemanticVersion("1.0.1"), MaxVersion = new SemanticVersion("1.2.3") }),
};
var packageVersion = new SemanticVersion("1.0.0");
var dependencySets = new PackageDependencySet[] {
new PackageDependencySet(null, dependencies)
};
// Act
PackageBuilder.ValidateDependencySets(packageVersion, dependencySets);
// Assert
// If we've got this far, no exceptions were thrown.
Assert.True(true);
}
public void AddPackageReferencePickPortableDependencySetOverFallbackDependencySet()
{
// Arrange
var sourceRepository = new MockPackageRepository();
var projectSystem = new MockProjectSystem(VersionUtility.ParseFrameworkName("portable-net45+wp8+windows8"));
var projectManager = new ProjectManager(sourceRepository, new DefaultPackagePathResolver(projectSystem), projectSystem, new MockPackageRepository());
var dependencySets = new PackageDependencySet[]
{
new PackageDependencySet(targetFramework: null, dependencies: new [] { PackageDependency.CreateDependency("B", "1.0.0")}),
new PackageDependencySet(targetFramework: VersionUtility.ParseFrameworkName("net45"), dependencies: new PackageDependency[0] { }),
new PackageDependencySet(targetFramework: VersionUtility.ParseFrameworkName("win8"), dependencies: new PackageDependency[0] { }),
new PackageDependencySet(targetFramework: VersionUtility.ParseFrameworkName("wp8"), dependencies: new PackageDependency[0] { }),
new PackageDependencySet(targetFramework: VersionUtility.ParseFrameworkName("portable-net45+win8+wp8"), dependencies: new PackageDependency[0] { }),
};
IPackage packageA = PackageUtility.CreatePackageWithDependencySets("A", "1.0", new[] { "me.txt" }, dependencySets: dependencySets);
IPackage packageB = PackageUtility.CreatePackage("B", "1.0", new[] { "you.txt" });
sourceRepository.AddPackage(packageA);
sourceRepository.AddPackage(packageB);
// Act
projectManager.AddPackageReference("A", null, ignoreDependencies: false, allowPrereleaseVersions: true);
// Assert
Assert.True(projectManager.LocalRepository.Exists("A"));
Assert.False(projectManager.LocalRepository.Exists("B"));
Assert.True(projectSystem.FileExists("me.txt"));
Assert.False(projectSystem.FileExists("you.txt"));
}
private JProperty WritePackageDependencySet(PackageDependencySet item)
{
return(new JProperty(
item.TargetFramework.ToStringSafe() ?? "*",
WriteObject(item.Dependencies, WritePackageDependency)));
}
public void ValidateDependenciesThrowsIfAnyDependencyForAStableReleaseIsPrerelease(VersionSpec versionSpec)
{
// Arrange
var badDependency = new PackageDependency("A", versionSpec);
var dependencies = new[] {
badDependency,
new PackageDependency("B", new VersionSpec()),
};
var packageVersion = new SemanticVersion("1.0.0");
var dependencySets = new PackageDependencySet[] {
new PackageDependencySet(null, dependencies)
};
// Act and Assert
ExceptionAssert.Throws<InvalidDataException>(() => PackageBuilder.ValidateDependencySets(packageVersion, dependencySets),
String.Format(CultureInfo.InvariantCulture,
"A stable release of a package should not have on a prerelease dependency. Either modify the version spec of dependency \"{0}\" or update the version field.",
badDependency));
}
private static VisualStudioUIPackageDependencySet GetVisualStudioUIPackageDependencySet(PackageDependencySet dependencySet)
{
IEnumerable <VisualStudioUIPackageDependency> visualStudioUIPackageDependencies = dependencySet.Dependencies.Select(d => GetVisualStudioUIPackageDependency(d));
FrameworkName fxName = dependencySet.TargetFramework;
return(new VisualStudioUIPackageDependencySet(fxName, visualStudioUIPackageDependencies));
}
public void SavingPackageWithInvalidDependencyVersionMaxLessThanMinThrows()
{
// Arrange
PackageBuilder builder = new PackageBuilder()
{
Id = "A",
Version = new SemanticVersion("1.0"),
Description = "Descriptions",
Summary = "Summary",
};
builder.Authors.Add("David");
var dependencySet = new PackageDependencySet(null, new[] {
new PackageDependency("B", new VersionSpec
{
MinVersion = new SemanticVersion("2.0"),
MaxVersion = new SemanticVersion("1.0")
})
});
builder.DependencySets.Add(dependencySet);
var ms = new MemoryStream();
// Act
ExceptionAssert.Throws<InvalidOperationException>(() => Manifest.Create(builder).Save(ms), "Dependency 'B' has an invalid version.");
}
public void SavingPackageWithDuplicateDependenciesThrows()
{
// Arrange
PackageBuilder builder = new PackageBuilder()
{
Id = "A",
Version = new SemanticVersion("1.0"),
Description = "Descriptions",
Summary = "Summary",
};
builder.Authors.Add("David");
var dependencySet = new PackageDependencySet(null, new[] {
new PackageDependency("B", new VersionSpec
{
MinVersion = new SemanticVersion("1.0"),
IsMinInclusive = true
}),
new PackageDependency("B", new VersionSpec
{
MinVersion = new SemanticVersion("1.0"),
MaxVersion = new SemanticVersion("5.0"),
IsMinInclusive = false
})
});
builder.DependencySets.Add(dependencySet);
var ms = new MemoryStream();
// Act
ExceptionAssert.Throws<InvalidOperationException>(() => Manifest.Create(builder).Save(ms), "'A' already has a dependency defined for 'B'.");
}
public void VersionFormatIsPreserved()
{
// Arrange
PackageBuilder builder = new PackageBuilder()
{
Id = "A",
Version = new SemanticVersion("1.0"),
Description = "Descriptions",
Summary = "Summary",
};
builder.Authors.Add("David");
var dependencySet = new PackageDependencySet(null, new [] {
new PackageDependency("B", new VersionSpec
{
MinVersion = new SemanticVersion("1.0"),
IsMinInclusive = true
}),
new PackageDependency("C", new VersionSpec
{
MinVersion = new SemanticVersion("1.0"),
MaxVersion = new SemanticVersion("5.0"),
IsMinInclusive = false
})
});
builder.DependencySets.Add(dependencySet);
var ms = new MemoryStream();
// Act
Manifest.Create(builder).Save(ms);
ms.Seek(0, SeekOrigin.Begin);
// Assert
Assert.Equal(@"<?xml version=""1.0""?>
<package xmlns=""http://schemas.microsoft.com/packaging/2010/07/nuspec.xsd"">
<metadata>
<id>A</id>
<version>1.0</version>
<authors>David</authors>
<owners>David</owners>
<requireLicenseAcceptance>false</requireLicenseAcceptance>
<description>Descriptions</description>
<summary>Summary</summary>
<dependencies>
<dependency id=""B"" version=""1.0"" />
<dependency id=""C"" version=""(1.0, 5.0)"" />
</dependencies>
</metadata>
</package>", ms.ReadToEnd());
}
private static NuGetFramework GetFramework(PackageDependencySet dependencySet)
{
var fxName = NuGetFramework.AnyFramework;
if (dependencySet.TargetFramework != null)
{
fxName = NuGetFramework.Parse(dependencySet.TargetFramework.FullName);
}
return fxName;
}
public void DependenciesAreFilteredByTargetFramework6()
{
// Arrange
var dependencySets = new PackageDependencySet[] {
new PackageDependencySet(
new FrameworkName("Silverlight, Version=2.0"),
new [] { new PackageDependency("A"), new PackageDependency("B") }
),
new PackageDependencySet(
new FrameworkName("Silverlight, Version=3.0"),
new [] { new PackageDependency("B"), new PackageDependency("C") }
),
new PackageDependencySet(
new FrameworkName(".NETFramework, Version=4.0"),
new PackageDependency[0]
),
};
var package = new Mock<IPackage>();
package.Setup(p => p.Id).Returns("P");
package.Setup(p => p.Version).Returns(new SemanticVersion("1.0"));
package.Setup(p => p.DependencySets).Returns(dependencySets);
var item = CreatePackageItem(package.Object);
item.TargetFramework = new FrameworkName(".NETFramework, Version=4.0");
// Act
var dependencies = item.Dependencies.ToList();
// Assert
Assert.Equal(0, dependencies.Count);
}
private static Stream GetPackageStream(string id, string version = "1.0")
{
var packageBuilder = new PackageBuilder
{
Id = id,
Version = SemanticVersion.Parse(version),
Description = "Test description",
};
var dependencySet = new PackageDependencySet(VersionUtility.DefaultTargetFramework,
new PackageDependency[] {
new PackageDependency("Foo")
});
packageBuilder.DependencySets.Add(dependencySet);
packageBuilder.Authors.Add("foo");
var memoryStream = new MemoryStream();
packageBuilder.Save(memoryStream);
memoryStream.Seek(0, SeekOrigin.Begin);
return memoryStream;
}
/// <summary>The initialize.</summary>
internal static void Initialize()
{
// Already initialized
if (packageVersion != null)
{
return;
}
DeleteOldPackages();
tempPackagesFolder = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
string installedPackages = Path.Combine(tempPackagesFolder, "Installed");
string packagesFolder = Path.Combine(tempPackagesFolder, "Packages");
Directory.CreateDirectory(installedPackages);
Directory.CreateDirectory(packagesFolder);
// Analyze StatusMonitor.nuget and find the dependency.
string nugetFolder = Path.GetDirectoryName(ExecutionEnvironment.StatusMonitorNugetPath);
IPackageRepository statusMonitorNugetRepo = PackageRepositoryFactory.Default.CreateRepository(nugetFolder);
IPackage package;
try
{
package = statusMonitorNugetRepo.FindPackage(StatusMonitorNugetId, (IVersionSpec)null, true, true);
}
catch (Exception ex)
{
throw new Exception(
string.Format(
"Could not find package '{0}' in '{1}': {2}",
StatusMonitorNugetId,
nugetFolder,
ex.Message),
ex);
}
PackageDependency dependency;
try
{
PackageDependencySet dependencySet = package.DependencySets.Single();
dependency = dependencySet.Dependencies.Single();
}
catch (Exception ex)
{
throw new Exception(string.Format("Dependency.Single threw an exception: '{0}'", ex.Message), ex);
}
// Copy to .\Packages folder
string statusMonitorNugetPath = ExecutionEnvironment.StatusMonitorNugetPath;
string nugetFileName = Path.GetFileName(statusMonitorNugetPath);
Debug.Assert(nugetFileName != null, "nugetFileName is null");
string outputPath = Path.Combine(packagesFolder, nugetFileName);
File.Copy(statusMonitorNugetPath, outputPath, true);
// Install all nugets which our StatusMonitor.nuget depends on. Download them from our own private nuget server
IPackageRepository packagesRepo =
PackageRepositoryFactory.Default.CreateRepository(NugetServerWithAllPackages);
var manager = new PackageManager(
packagesRepo,
new DefaultPackagePathResolver(installedPackages),
new PhysicalFileSystem(installedPackages));
try
{
manager.InstallPackage(dependency.Id, dependency.VersionSpec.MinVersion, false, true);
}
catch (Exception ex)
{
throw new Exception(
string.Format(
"Could not install package: '{0}', '{1}' from '{2}': {3}",
dependency.Id,
dependency.VersionSpec.MinVersion,
NugetServerWithAllPackages,
ex.Message),
ex);
}
// Copy all *.nupkg files to .\Packages folder
foreach (string newPath in Directory.GetFiles(installedPackages, "*.nupkg", SearchOption.AllDirectories))
{
string fileName = Path.GetFileName(newPath);
Debug.Assert(fileName != null, "fileName is null");
string output = Path.Combine(packagesFolder, fileName);
File.Copy(newPath, output, true);
}
// Now let StatusMonitor to download these packages
string arguments = string.Format(
"/c {0} download \"{1}\" \"{2}\"",
ExecutionEnvironment.StatusMonitorLauncherPath,
StatusMonitorInstallPath,
packagesFolder);
ProcessHelper.ExecuteProcess("cmd.exe", arguments, TimeSpan.FromMinutes(1));
// Get downloaded version
packageVersion = GetPackageVersion();
}
public void RemovePackageReferenceRemoveDependencyPackageCorrectly(string dependencyVersion)
{
// Arrange
var sourceRepository = new MockPackageRepository();
var projectSystem = new MockProjectSystem(new FrameworkName(".NETFramework", new Version("4.0")));
var projectManager = new ProjectManager(sourceRepository, new DefaultPackagePathResolver(projectSystem), projectSystem, new MockPackageRepository());
var dependency = new PackageDependency("B", null);
var dependencySet = new PackageDependencySet(
new FrameworkName(".NETFramework", new Version(dependencyVersion)),
new PackageDependency[] { dependency });
IPackage packageA = PackageUtility.CreatePackageWithDependencySets("A", "1.0",
dependencySets: new List<PackageDependencySet> { dependencySet },
content: new[] { "a.txt" });
IPackage packageB = PackageUtility.CreatePackage("B", "1.0", content: new[] { "b.txt" });
sourceRepository.AddPackage(packageB);
sourceRepository.AddPackage(packageA);
projectManager.AddPackageReference("A");
Assert.True(projectManager.LocalRepository.Exists("A"));
Assert.True(projectManager.LocalRepository.Exists("B"));
Assert.True(projectSystem.FileExists("a.txt"));
Assert.True(projectSystem.FileExists("b.txt"));
// Act
projectManager.RemovePackageReference("A", forceRemove: false, removeDependencies: true);
Assert.False(projectManager.LocalRepository.Exists("A"));
Assert.False(projectManager.LocalRepository.Exists("B"));
Assert.False(projectSystem.FileExists("a.txt"));
Assert.False(projectSystem.FileExists("b.txt"));
}
public void ValidateDependenciesDoesNotThrowIfDependencyForAPrereleaseVersionIsPrerelease(VersionSpec versionSpec)
{
// Arrange
var dependencies = new[] {
new PackageDependency("A", versionSpec),
new PackageDependency("B", new VersionSpec()),
};
var packageVersion = new SemanticVersion("1.0.0-beta");
var dependencySets = new PackageDependencySet[] {
new PackageDependencySet(null, dependencies)
};
// Act
PackageBuilder.ValidateDependencySets(packageVersion, dependencySets);
// Assert
// If we've got this far, no exceptions were thrown.
Assert.True(true);
}
private static VisualStudioUIPackageDependencySet GetVisualStudioUIPackageDependencySet(PackageDependencySet dependencySet)
{
IEnumerable<VisualStudioUIPackageDependency> visualStudioUIPackageDependencies = dependencySet.Dependencies.Select(d => GetVisualStudioUIPackageDependency(d));
FrameworkName fxName = dependencySet.TargetFramework;
return new VisualStudioUIPackageDependencySet(fxName, visualStudioUIPackageDependencies);
}
private IEnumerable<string> ConvertDependencySetToStrings(PackageDependencySet dependencySet)
{
if (dependencySet.Dependencies.Count == 0)
{
if (dependencySet.TargetFramework != null)
{
// if this Dependency set is empty, we still need to send down one string of the form "::<target framework>",
// so that the client can reconstruct an empty group.
return new string[] { String.Format("::{0}", VersionUtility.GetShortFrameworkName(dependencySet.TargetFramework)) };
}
}
else
{
return dependencySet.Dependencies.Select(dependency => ConvertDependency(dependency, dependencySet.TargetFramework));
}
return new string[0];
}
