public PackageDependencySetMetadata(PackageDependencyGroup dependencyGroup)
{
TargetFramework = dependencyGroup.TargetFramework;
Dependencies = dependencyGroup.Packages
.Select(d => new PackageDependencyMetadata(d))
.ToList()
.AsReadOnly();
}
private static IList <LibraryDependency> GetDependencies(NuGetFramework targetFramework,
PackageDependencyGroup dependencies,
FrameworkSpecificGroup frameworkAssemblies)
{
var libraryDependencies = new List <LibraryDependency>();
if (dependencies != null)
{
foreach (var d in dependencies.Packages)
{
libraryDependencies.Add(new LibraryDependency
{
LibraryRange = new LibraryRange
{
Name = d.Id,
VersionRange = d.VersionRange
}
});
}
}
if (frameworkAssemblies == null)
{
return(libraryDependencies);
}
if (!targetFramework.IsDesktop())
{
// REVIEW: This isn't 100% correct since none *can* mean
// any in theory, but in practice it means .NET full reference assembly
// If there's no supported target frameworks and we're not targeting
// the desktop framework then skip it.
// To do this properly we'll need all reference assemblies supported
// by each supported target framework which isn't always available.
return(libraryDependencies);
}
foreach (var name in frameworkAssemblies.Items)
{
libraryDependencies.Add(new LibraryDependency
{
LibraryRange = new LibraryRange
{
Name = name,
TypeConstraint = LibraryTypes.Reference
}
});
}
return(libraryDependencies);
}
private static IList<LibraryDependency> GetDependencies(NuGetFramework targetFramework,
PackageDependencyGroup dependencies,
FrameworkSpecificGroup frameworkAssemblies)
{
var libraryDependencies = new List<LibraryDependency>();
if (dependencies != null)
{
foreach (var d in dependencies.Packages)
{
libraryDependencies.Add(new LibraryDependency
{
LibraryRange = new LibraryRange
{
Name = d.Id,
VersionRange = d.VersionRange
}
});
}
}
if (frameworkAssemblies == null)
{
return libraryDependencies;
}
if (!targetFramework.IsDesktop())
{
// REVIEW: This isn't 100% correct since none *can* mean
// any in theory, but in practice it means .NET full reference assembly
// If there's no supported target frameworks and we're not targeting
// the desktop framework then skip it.
// To do this properly we'll need all reference assemblies supported
// by each supported target framework which isn't always available.
return libraryDependencies;
}
foreach (var name in frameworkAssemblies.Items)
{
libraryDependencies.Add(new LibraryDependency
{
LibraryRange = new LibraryRange
{
Name = name,
TypeConstraint = LibraryTypes.Reference
}
});
}
return libraryDependencies;
}
/// <summary>
/// Creates test package from assembly
/// </summary>
/// <param name="assembly">The source assembly</param>
/// <param name="allAssemblies">The list of all defined assemblies</param>
/// <returns>The test package</returns>
private static TestPackage CreateTestPackage(Assembly assembly, Assembly[] allAssemblies)
{
var dependencies = assembly.GetReferencedAssemblies().Select(
d =>
{
var dependentAssembly = allAssemblies.FirstOrDefault(a => a.GetName().Name == d.Name);
return(dependentAssembly != null && !dependentAssembly.IsDynamic
#if APPDOMAIN
&& !dependentAssembly.GlobalAssemblyCache
#endif
? dependentAssembly
: null);
}).Where(d => d != null).Select(
d => new PackageDependency(
d.GetName().Name,
new VersionRange(NuGetVersion.Parse(d.GetName().Version.ToString())))).ToList();
var standardDependencies = new PackageDependencyGroup(
NuGetFramework.ParseFrameworkName(
ConfigurationCheckTestsBase.NetCore,
DefaultFrameworkNameProvider.Instance),
dependencies);
var net46Dependencies = new PackageDependencyGroup(
NuGetFramework.ParseFrameworkName(
ConfigurationCheckTestsBase.Net46,
DefaultFrameworkNameProvider.Instance),
dependencies);
Func <string, string, string, IEnumerable <string> > extaction = (framework, destination, temp) =>
{
if (string.IsNullOrWhiteSpace(assembly.Location))
{
throw new InvalidOperationException("Assembly has no location");
}
var fileName = Path.GetFileName(assembly.Location);
File.Copy(assembly.Location, Path.Combine(destination, fileName));
return(new[] { fileName });
};
return(new TestPackage(assembly.GetName().Name, assembly.GetName().Version.ToString())
{
DependencySets =
new[]
{
standardDependencies,
net46Dependencies
},
Extract =
extaction
});
}
private static void AssertDependencyGroup(PackageDependencyGroup expected, PackageDependencyGroup actual)
{
Assert.Equal(expected.TargetFramework, actual.TargetFramework);
var actualDependencies = actual.Packages.ToList();
var expectedDependencies = expected.Packages.ToList();
Assert.Equal(expectedDependencies.Count, actualDependencies.Count);
for (int i = 0; i < expectedDependencies.Count; i++)
{
AssertDependency(expectedDependencies[i], actualDependencies[i]);
}
}
private static IList <LibraryDependency> GetDependencies(NuGetFramework targetFramework,
PackageDependencyGroup dependencies)
{
List <LibraryDependency> libraryDependencies = new List <LibraryDependency>();
if (dependencies != null)
{
libraryDependencies.AddRange(
dependencies.Packages.Select(PackagingUtility.GetLibraryDependencyFromNuspec));
}
return(libraryDependencies);
}
public async Task DependencyCommandTests_ClearExclude()
{
using (var workingDir = new TestFolder())
{
// Arrange
var testPackageA = new TestNupkg()
{
Nuspec = new TestNuspec()
{
Id = "a",
Version = "1.0.0"
}
};
var depGroup1 = new PackageDependencyGroup(NuGetFramework.Parse("net45"), new[] {
new PackageDependency("b", VersionRange.Parse("1.0.0"))
});
var depGroup2 = new PackageDependencyGroup(NuGetFramework.Parse("any"), new[] {
new PackageDependency("b", VersionRange.Parse("2.0.0"), new[] { "build" }, new[] { "content" }),
new PackageDependency("x", VersionRange.Parse("1.0.0"), new[] { "build" }, new[] { "content" }),
});
testPackageA.Nuspec.Dependencies.Add(depGroup1);
testPackageA.Nuspec.Dependencies.Add(depGroup2);
var zipFileA = testPackageA.Save(workingDir.Root);
var log = new TestLogger();
// Act
var exitCode = await Program.MainCore(new[] { "nuspec", "dependencies", "modify", workingDir.Root, "--dependency-id", "b", "--clear-exclude" }, log);
exitCode.Should().Be(0, log.GetMessages());
var nuspecA = GetNuspec(Path.Combine(workingDir.Root, "a.1.0.0.nupkg"));
var groups = nuspecA.GetDependencyGroups().ToDictionary(e => e.TargetFramework.GetShortFolderName().ToLowerInvariant());
// Assert
groups.Count().Should().Be(2);
groups["net45"].Packages.Single(e => e.Id == "b").VersionRange.Should().Be(VersionRange.Parse("1.0.0"));
groups["net45"].Packages.Single(e => e.Id == "b").Exclude.Should().BeEmpty();
groups["net45"].Packages.Single(e => e.Id == "b").Include.Should().BeEmpty();
groups["any"].Packages.FirstOrDefault(e => e.Id == "b").VersionRange.Should().Be(VersionRange.Parse("2.0.0"));
groups["any"].Packages.FirstOrDefault(e => e.Id == "b").Exclude.Should().BeEmpty();
groups["any"].Packages.FirstOrDefault(e => e.Id == "b").Include.ShouldBeEquivalentTo(new[] { "build" });
groups["any"].Packages.FirstOrDefault(e => e.Id == "x").VersionRange.Should().Be(VersionRange.Parse("1.0.0"));
groups["any"].Packages.FirstOrDefault(e => e.Id == "x").Include.ShouldBeEquivalentTo(new[] { "build" });
groups["any"].Packages.FirstOrDefault(e => e.Id == "x").Exclude.ShouldBeEquivalentTo(new[] { "content" });
}
}
public async Task Command_ReleaseCommand_VersionOutsideOfOriginalRange()
{
using (var workingDir = new TestFolder())
{
// Arrange
var testPackageA = new TestNupkg()
{
Nuspec = new TestNuspec()
{
Id = "a",
Version = "6.0.0"
}
};
var depGroup = new PackageDependencyGroup(NuGetFramework.Parse("net45"), new[] {
new PackageDependency("b", VersionRange.Parse("[1.0.0, 2.0.0]"))
});
testPackageA.Nuspec.Dependencies.Add(depGroup);
var testPackageB = new TestNupkg()
{
Nuspec = new TestNuspec()
{
Id = "b",
Version = "6.0.0"
}
};
var zipFileA = testPackageA.Save(workingDir.Root);
var zipFileB = testPackageB.Save(workingDir.Root);
var log = new TestLogger();
// Act
var exitCode = await Program.MainCore(new[] { "release", workingDir.Root, "-n", "9.0.0" }, log);
var nuspecA = GetNuspec(Path.Combine(workingDir.Root, "a.9.0.0.nupkg"));
var dependencyB = nuspecA.GetDependencyGroups().Single().Packages.Single(e => e.Id == "b");
var dependencyBString = dependencyB.VersionRange.ToLegacyShortString();
// Assert
Assert.Equal(0, exitCode);
Assert.Equal("[1.0.0, 2.0.0]", dependencyBString);
Assert.Contains("dependency b does not allow the original version of b 6.0.0. Skipping.", string.Join("|", log.Messages));
}
}
public async Task DependencyCommandTests_AddVerifyAddWithNewFramework()
{
using (var workingDir = new TestFolder())
{
// Arrange
var testPackageA = new TestNupkg()
{
Nuspec = new TestNuspec()
{
Id = "a",
Version = "1.0.0"
}
};
var depGroup1 = new PackageDependencyGroup(NuGetFramework.Parse("net45"), new[] {
new PackageDependency("b", VersionRange.Parse("1.0.0"))
});
var depGroup2 = new PackageDependencyGroup(NuGetFramework.Parse("net46"), new[] {
new PackageDependency("b", VersionRange.Parse("2.0.0"))
});
testPackageA.Nuspec.Dependencies.Add(depGroup1);
testPackageA.Nuspec.Dependencies.Add(depGroup2);
var zipFileA = testPackageA.Save(workingDir.Root);
var log = new TestLogger();
// Act
var exitCode = await Program.MainCore(new[] { "nuspec", "dependencies", "add", workingDir.Root, "--dependency-id", "c", "--dependency-version", "1.0.0", "--framework", "any" }, log);
exitCode.Should().Be(0, log.GetMessages());
var nuspecA = GetNuspec(Path.Combine(workingDir.Root, "a.1.0.0.nupkg"));
var groups = nuspecA.GetDependencyGroups();
var dependencyCAny = groups.Single(e => e.TargetFramework.IsAny).Packages.FirstOrDefault(e => e.Id == "c");
var dependencyCNet45 = groups.Single(e => e.TargetFramework == NuGetFramework.Parse("net45")).Packages.FirstOrDefault(e => e.Id == "c");
var dependencyCNet46 = groups.Single(e => e.TargetFramework == NuGetFramework.Parse("net46")).Packages.FirstOrDefault(e => e.Id == "c");
// Assert
dependencyCNet45.Should().BeNull();
dependencyCNet46.Should().BeNull();
dependencyCAny.VersionRange.Should().Be(VersionRange.Parse("1.0.0"));
nuspecA.GetDependencyGroups().Count().Should().Be(3);
}
}
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);
packageBuilder.PackageTypes = new[] { new PackageType(NuGet.Constants.GalleryPackageType, PackageType.EmptyVersion) };
var files = manifest.Files ?? GetContentFiles(basePath);
packageBuilder.PopulateFiles(basePath, files);
var manifestDependencies = new Dictionary <string, PackageDependency>(StringComparer.OrdinalIgnoreCase);
foreach (var dependency in packageBuilder.DependencyGroups.Where(group => group.TargetFramework == NuGetFramework.AnyFramework)
.SelectMany(group => group.Packages))
{
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)
{
if (!manifestDependencies.TryGetValue(dependency.Id, out PackageDependency manifestDependency) ||
!DependencyEqualityComparer.Default.Equals(dependency, manifestDependency))
{
updateDependencies = true;
manifestDependencies[dependency.Id] = dependency;
}
}
var dependencyGroup = new PackageDependencyGroup(NuGetFramework.AnyFramework, manifestDependencies.Values);
packageBuilder.DependencyGroups.Clear();
packageBuilder.DependencyGroups.Add(dependencyGroup);
return(packageBuilder);
}
private void AddFlattenedFrameworkDependency(PackageDependencyGroup dependencyGroup, StringBuilder builder)
{
if (!SpecialFrameworks.Contains(dependencyGroup.TargetFramework))
{
try
{
builder.Append(":");
builder.Append(dependencyGroup.TargetFramework?.GetShortFolderName());
}
catch (FrameworkException)
{
// ignoring FrameworkException on purpose - we don't want the job crashing
// whenever someone uploads an unsupported framework
}
}
}
public async Task Command_ReleaseCommand_NewVersionBelowMin()
{
using (var workingDir = new TestFolder())
{
// Arrange
var testPackageA = new TestNupkg()
{
Nuspec = new TestNuspec()
{
Id = "a",
Version = "6.0.0"
}
};
var depGroup = new PackageDependencyGroup(NuGetFramework.Parse("net45"), new[] {
new PackageDependency("b", VersionRange.Parse("5.0.0"))
});
testPackageA.Nuspec.Dependencies.Add(depGroup);
var testPackageB = new TestNupkg()
{
Nuspec = new TestNuspec()
{
Id = "b",
Version = "6.0.0"
}
};
var zipFileA = testPackageA.Save(workingDir.Root);
var zipFileB = testPackageB.Save(workingDir.Root);
var log = new TestLogger();
// Act
var exitCode = await Program.MainCore(new[] { "release", workingDir.Root, "-n", "1.0.0" }, log);
var nuspecA = GetNuspec(Path.Combine(workingDir.Root, "a.1.0.0.nupkg"));
var dependencyB = nuspecA.GetDependencyGroups().Single().Packages.Single(e => e.Id == "b");
var dependencyBString = dependencyB.VersionRange.ToLegacyShortString();
// Assert
Assert.Equal(0, exitCode);
Assert.Equal("1.0.0", dependencyBString);
}
}
/// <summary>
/// Converts a <see cref="ManifestMetadata"/> into a <see cref="NuGetManifestMetadata"/>.
/// </summary>
/// <param name="metadata">The metadata source of conversion.</param>
/// <returns>A new instance of <see cref="NuGetManifestMetadata"/> corresponding to <paramref name="metadata"/>.</returns>
public static NuGetManifestMetadata ToManifestMetadata(this ManifestMetadata metadata)
{
if (metadata == null)
{
throw new ArgumentNullException(nameof(metadata));
}
var nugetMetadata = new NuGetManifestMetadata()
{
Id = metadata.Id,
Authors = metadata.Authors,
Description = metadata.Description,
Copyright = metadata.Copyright,
DevelopmentDependency = metadata.DevelopmentDependency,
Version = new NuGetVersion(metadata.Version),
Owners = metadata.Owners,
Language = metadata.Language,
MinClientVersionString = metadata.MinClientVersionString,
ReleaseNotes = metadata.ReleaseNotes,
RequireLicenseAcceptance = metadata.RequireLicenseAcceptance,
Summary = metadata.Summary,
Tags = metadata.Tags,
Title = metadata.Title
};
// Setting properties without a setter.
nugetMetadata.SetIconUrl(metadata.IconUrl);
nugetMetadata.SetLicenseUrl(metadata.LicenseUrl);
nugetMetadata.SetProjectUrl(metadata.ProjectUrl);
// Updating dependencies
if (metadata.Dependencies.Count != 0)
{
var packages = new List <PackageDependency>();
foreach (var dependency in metadata.Dependencies)
{
packages.Add(new PackageDependency(dependency.Id, dependency.Version.ToVersionRange()));
}
// We are .NET agnostic
var group = new PackageDependencyGroup(NuGetFramework.AgnosticFramework, packages);
nugetMetadata.DependencyGroups = new [] { group };
}
return(nugetMetadata);
}
public async Task Command_DependenciesEmptyGroupCommand_AddNew()
{
using (var workingDir = new TestFolder())
{
// Arrange
var testPackage = new TestNupkg()
{
Nuspec = new TestNuspec()
{
Id = "a",
Version = "1.0.0"
}
};
var depGroup1 = new PackageDependencyGroup(NuGetFramework.Parse("net45"), new[] {
new PackageDependency("b", VersionRange.Parse("2.0.0-alpha")),
new PackageDependency("c", VersionRange.Parse("[1.0.0-beta]"))
});
var depGroup2 = new PackageDependencyGroup(NuGetFramework.Parse("netstandard1.6"), new[] {
new PackageDependency("b", VersionRange.Parse("2.0.0-alpha")),
new PackageDependency("c", VersionRange.Parse("[1.0.0-beta]"))
});
testPackage.Nuspec.Dependencies.Add(depGroup1);
testPackage.Nuspec.Dependencies.Add(depGroup2);
var zipFile = testPackage.Save(workingDir.Root);
var log = new TestLogger();
// Act
var exitCode = await Program.MainCore(new[] { "nuspec", "dependencies", "emptygroup", zipFile.FullName, "-f", "win8" }, log);
var nuspec = GetNuspec(zipFile.FullName);
// Assert
Assert.Equal(0, exitCode);
Assert.Equal(3, nuspec.GetDependencyGroups().Count());
Assert.Equal(2, nuspec.GetDependencyGroups().Where(e => e.TargetFramework.Equals(NuGetFramework.Parse("net45"))).Single().Packages.Count());
Assert.Equal(2, nuspec.GetDependencyGroups().Where(e => e.TargetFramework.Equals(NuGetFramework.Parse("netstandard1.6"))).Single().Packages.Count());
nuspec.GetDependencyGroups().Where(e => e.TargetFramework.Equals(NuGetFramework.Parse("win8"))).Single().Packages.Should().BeEmpty();
}
}
private void AddFlattennedPackageDependency(
PackageDependencyGroup dependencyGroup,
Packaging.Core.PackageDependency packageDependency,
StringBuilder builder)
{
if (builder.Length > 0)
{
builder.Append("|");
}
builder.Append(packageDependency.Id);
builder.Append(":");
if (!packageDependency.VersionRange.Equals(VersionRange.All))
{
builder.Append(packageDependency.VersionRange?.ToString("S", new VersionRangeFormatter()));
}
AddFlattenedFrameworkDependency(dependencyGroup, builder);
}
private void BuildNuSpecManifest_After(object sender, BuildNuSpecManifestEventArgs e)
{
if (e.ResourceName.Equals("RelationshipsExtended", StringComparison.InvariantCultureIgnoreCase))
{
e.Manifest.Metadata.SetIconUrl("https://www.kentico.com/icons/icon-48x48.png");
e.Manifest.Metadata.SetProjectUrl("https://github.com/KenticoDevTrev/RelationshipsExtended");
e.Manifest.Metadata.ReleaseNotes = "Adjusted library nuget package to depend on RelationshipsExtended.Base for easier maintenance";
e.Manifest.Metadata.Copyright = "Heartland Business Systems";
// Add dependencies
List <PackageDependency> NetStandardDependencies = new List <PackageDependency>()
{
new PackageDependency("Kentico.Xperience.Libraries", new VersionRange(new NuGetVersion("13.0.0")), new string[] { }, new string[] { "Build", "Analyzers" }),
new PackageDependency("RelationshipsExtended.Base", new VersionRange(new NuGetVersion("13.0.1")), new string[] { }, new string[] { "Build", "Analyzers" })
};
PackageDependencyGroup PackageGroup = new PackageDependencyGroup(new NuGet.Frameworks.NuGetFramework(".NETStandard2.0"), NetStandardDependencies);
e.Manifest.Metadata.DependencyGroups = new PackageDependencyGroup[] { PackageGroup };
}
}
public async Task DependencyCommandTests_RemoveWithFrameworkThatDoesExist()
{
using (var workingDir = new TestFolder())
{
// Arrange
var testPackageA = new TestNupkg()
{
Nuspec = new TestNuspec()
{
Id = "a",
Version = "1.0.0"
}
};
var depGroup1 = new PackageDependencyGroup(NuGetFramework.Parse("net45"), new[] {
new PackageDependency("b", VersionRange.Parse("1.0.0"))
});
var depGroup2 = new PackageDependencyGroup(NuGetFramework.Parse("net46"), new[] {
new PackageDependency("b", VersionRange.Parse("2.0.0"))
});
testPackageA.Nuspec.Dependencies.Add(depGroup1);
testPackageA.Nuspec.Dependencies.Add(depGroup2);
var zipFileA = testPackageA.Save(workingDir.Root);
var log = new TestLogger();
// Act
var exitCode = await Program.MainCore(new[] { "nuspec", "dependencies", "remove", workingDir.Root, "--dependency-id", "b", "--framework", "net46" }, log);
exitCode.Should().Be(0, log.GetMessages());
var nuspecA = GetNuspec(Path.Combine(workingDir.Root, "a.1.0.0.nupkg"));
var groups = nuspecA.GetDependencyGroups().ToDictionary(e => e.TargetFramework.GetShortFolderName().ToLowerInvariant());
// Assert
groups.Count().Should().Be(2);
groups["net45"].Packages.ShouldBeEquivalentTo(depGroup1.Packages);
groups["net46"].Packages.Should().BeEmpty();
}
}
private Manifest TransformManifestToPackedPackageManifest(Manifest manifest)
{
ManifestMetadata manifestMetadata = manifest.Metadata;
// Update Id
string _packageNamePrefix = PackedPackageNamePrefix != null ? PackedPackageNamePrefix : _defaultPackedPackagePrefix;
manifestMetadata.Id = $"{_packageNamePrefix}.{manifestMetadata.Id}";
// Update dependencies
List <PackageDependencyGroup> packedPackageDependencyGroups = new List <PackageDependencyGroup>();
foreach (var dependencyGroup in manifestMetadata.DependencyGroups)
{
List <NuGet.Packaging.Core.PackageDependency> packages = new List <NuGet.Packaging.Core.PackageDependency>();
foreach (var dependency in dependencyGroup.Packages)
{
NuGet.Packaging.Core.PackageDependency package = new NuGet.Packaging.Core.PackageDependency($"{_packageNamePrefix}.{dependency.Id}", dependency.VersionRange, dependency.Include, dependency.Exclude);
packages.Add(package);
}
PackageDependencyGroup packageDependencyGroup = new PackageDependencyGroup(dependencyGroup.TargetFramework, packages);
packedPackageDependencyGroups.Add(packageDependencyGroup);
}
manifestMetadata.DependencyGroups = packedPackageDependencyGroups;
// Update runtime.json
List <ManifestFile> manifestFiles = new List <ManifestFile>();
foreach (ManifestFile file in manifest.Files)
{
string fileName = file.Source;
if (Path.GetFileName(fileName) == "runtime.json" && file.Target == "")
{
string packedPackageSourcePath = Path.Combine(Path.GetDirectoryName(fileName), string.Join(".", _packageNamePrefix, Path.GetFileName(fileName)));
file.Source = File.Exists(packedPackageSourcePath) ? packedPackageSourcePath : fileName;
file.Target = "runtime.json";
}
manifestFiles.Add(file);
}
Manifest packedPackageManifest = new Manifest(manifestMetadata, manifestFiles);
return(manifest);
}
public async Task Command_DependenciesClearCommand_Filter()
{
using (var workingDir = new TestFolder())
{
// Arrange
var testPackage = new TestNupkg()
{
Nuspec = new TestNuspec()
{
Id = "a",
Version = "1.0.0"
}
};
var depGroup1 = new PackageDependencyGroup(NuGetFramework.Parse("net45"), new[] {
new PackageDependency("b", VersionRange.Parse("2.0.0-alpha")),
new PackageDependency("c", VersionRange.Parse("[1.0.0-beta]"))
});
var depGroup2 = new PackageDependencyGroup(NuGetFramework.Parse("netstandard1.6"), new[] {
new PackageDependency("b", VersionRange.Parse("2.0.0-alpha")),
new PackageDependency("c", VersionRange.Parse("[1.0.0-beta]"))
});
testPackage.Nuspec.Dependencies.Add(depGroup1);
testPackage.Nuspec.Dependencies.Add(depGroup2);
var zipFile = testPackage.Save(workingDir.Root);
var log = new TestLogger();
// Act
var exitCode = await Program.MainCore(new[] { "nuspec", "dependencies", "clear", zipFile.FullName, "-f", "net45" }, log);
var nuspec = GetNuspec(zipFile.FullName);
// Assert
Assert.Equal(0, exitCode);
Assert.Equal(1, nuspec.GetDependencyGroups().Count());
}
}
public static string CreateTestPackage(
string packageId,
string version,
string path,
string framework,
string dependencyPackageId,
string dependencyPackageVersion)
{
var group = new PackageDependencyGroup(NuGetFramework.AnyFramework, new List <PackageDependency>()
{
new PackageDependency(dependencyPackageId, VersionRange.Parse(dependencyPackageVersion))
});
return(CreateTestPackage(packageId, version, path,
new List <NuGetFramework>()
{
NuGetFramework.Parse(framework)
},
new List <PackageDependencyGroup>()
{
group
}));
}
public PackageDependencySetMetadata(PackageDependencyGroup dependencyGroup)
{
if (dependencyGroup == null)
{
TargetFrameworkDisplay = Resources.Text_NoDependencies;
}
else
{
TargetFramework = dependencyGroup.TargetFramework;
TargetFrameworkDisplay = TargetFramework.ToString();
if (dependencyGroup.Packages.Any())
{
Dependencies = dependencyGroup.Packages
.Select(d => new PackageDependencyMetadata(d))
.ToList()
.AsReadOnly();
}
else
{
Dependencies = NoDependenciesPlaceholder;
}
}
}
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));
}
}
private void FilterDependencies(string targetPath, ISet <string> dependencyToRemove)
{
var fileName = Path.GetFileName(targetPath);
Log.LogMessage($"Updating {fileName}");
using (var fileStream = File.Open(targetPath, FileMode.Open))
using (var package = new ZipArchive(fileStream, ZipArchiveMode.Update))
using (var packageReader = new PackageArchiveReader(fileStream, leaveStreamOpen: true))
{
var referencesFrameworkOnlyAssembly = false;
var nuspecFile = packageReader.GetNuspecFile();
using (var stream = package.OpenFile(nuspecFile))
{
var reader = Manifest.ReadFrom(stream, validateSchema: true);
stream.Position = 0;
var packageBuilder = new PackageBuilder(stream, basePath: null);
var updatedGroups = new List <PackageDependencyGroup>();
foreach (var group in packageBuilder.DependencyGroups)
{
var packages = new List <PackageDependency>();
var updatedGroup = new PackageDependencyGroup(group.TargetFramework, packages);
foreach (var dependency in group.Packages)
{
if (dependencyToRemove.Contains(dependency.Id))
{
referencesFrameworkOnlyAssembly = true;
Log.LogMessage($" Remove dependency on '{dependency.Id}'");
continue;
}
packages.Add(dependency);
}
updatedGroups.Add(updatedGroup);
}
if (referencesFrameworkOnlyAssembly)
{
packageBuilder.DependencyGroups.Clear();
packageBuilder.DependencyGroups.AddRange(updatedGroups);
var updatedManifest = Manifest.Create(packageBuilder);
var inMemory = new MemoryStream();
updatedManifest.Save(inMemory);
inMemory.Position = 0;
// Hack the raw nuspec to add the <frameworkReference> dependency
var rawNuspec = XDocument.Load(inMemory, LoadOptions.PreserveWhitespace);
var ns = rawNuspec.Root.GetDefaultNamespace();
var metadata = rawNuspec.Root.Descendants(ns + "metadata").Single();
metadata.Add(
new XElement(ns + "frameworkReferences",
new XElement(ns + "group",
new XAttribute("targetFramework", NuGetFramework.Parse(SharedFrameworkTargetFramework).GetFrameworkString()),
new XElement(ns + "frameworkReference", new XAttribute("name", "Microsoft.AspNetCore.App")))));
stream.Position = 0;
stream.SetLength(0);
rawNuspec.Save(stream);
Log.LogMessage(MessageImportance.High, "Added <frameworkReference> to {0}", fileName);
}
else
{
Log.LogMessage($"No changes made to {fileName}");
}
}
}
}
/// <summary>
/// For each package in our registry.json, query NuGet, extract package metadata, and convert them to unity packages.
/// </summary>
private async Task BuildInternal()
{
var packageMetadataResource = _sourceRepository.GetResource <PackageMetadataResource>();
foreach (var packageDesc in _registry)
{
var packageName = packageDesc.Key;
var packageEntry = packageDesc.Value;
// A package entry is ignored but allowed in the registry (case of Microsoft.CSharp)
if (packageEntry.Ignored)
{
continue;
}
var packageMetaIt = await packageMetadataResource.GetMetadataAsync(packageName, false, false, _sourceCacheContext, Logger, CancellationToken.None);
var packageMetas = packageMetaIt.ToList();
foreach (var packageMeta in packageMetas)
{
var packageIdentity = packageMeta.Identity;
var packageId = packageIdentity.Id.ToLowerInvariant();
var npmPackageId = $"{UnityScope}.{packageId}";
if (!packageEntry.Version.Satisfies(packageMeta.Identity.Version))
{
continue;
}
PackageDependencyGroup netstd20Dependency = null;
foreach (var dependencySet in packageMeta.DependencySets)
{
if (dependencySet.TargetFramework == NuGetFrameworkNetStandard20)
{
netstd20Dependency = dependencySet;
break;
}
}
if (netstd20Dependency == null)
{
Logger.LogWarning($"The package `{packageIdentity}` doesn't support `netstandard2.0`");
continue;
}
if (!_npmPackageRegistry.Packages.TryGetValue(npmPackageId, out var npmPackage))
{
npmPackage = new NpmPackage();
_npmPackageRegistry.Packages.Add(npmPackageId, npmPackage);
}
// One NpmPackage (for package request)
var packageInfoList = packageEntry.Listed ? _npmPackageRegistry.ListedPackageInfos : _npmPackageRegistry.UnlistedPackageInfos;
if (!packageInfoList.Packages.TryGetValue(npmPackageId, out var npmPackageInfo))
{
npmPackageInfo = new NpmPackageInfo();
packageInfoList.Packages.Add(npmPackageId, npmPackageInfo);
}
// Update latest version
var currentVersion = packageIdentity.Version;
var update = !npmPackage.DistTags.TryGetValue("latest", out var latestVersion) ||
(currentVersion > NuGetVersion.Parse(latestVersion));
string npmCurrentVersion = $"{currentVersion.Major}.{currentVersion.Minor}.{currentVersion.Patch}";
if (currentVersion.Revision != 0)
{
npmCurrentVersion += $"-{currentVersion.Revision}";
}
if (update)
{
npmPackage.DistTags["latest"] = npmCurrentVersion;
npmPackageInfo.Versions.Clear();
npmPackageInfo.Versions[npmCurrentVersion] = "latest";
npmPackage.Id = npmPackageId;
npmPackage.License = packageMeta.LicenseMetadata?.License ?? packageMeta.LicenseUrl?.ToString();
npmPackage.Name = npmPackageId;
npmPackageInfo.Name = npmPackageId;
npmPackage.Description = packageMeta.Description;
npmPackageInfo.Description = packageMeta.Description;
npmPackageInfo.Author = packageMeta.Authors;
if (packageMeta.Owners != null)
{
npmPackageInfo.Maintainers.Clear();
npmPackageInfo.Maintainers.AddRange(SplitCommaSeparatedString(packageMeta.Owners));
}
if (packageMeta.Tags != null)
{
npmPackageInfo.Keywords.Clear();
npmPackageInfo.Keywords.Add("nuget");
npmPackageInfo.Keywords.AddRange(SplitCommaSeparatedString(packageMeta.Tags));
}
}
var npmVersion = new NpmPackageVersion
{
Id = $"{npmPackageId}@{npmCurrentVersion}",
Version = npmCurrentVersion,
Name = npmPackageId,
Description = packageMeta.Description,
Author = AuthorNameUnityGroup,
DisplayName = $"{packageMeta.Title} ({npmPackageInfo.Author})"
};
npmVersion.Distribution.Tarball = new Uri($"{RootHttpUrl}/{npmPackage.Id}/-/{GetUnityPackageFileName(packageIdentity, npmVersion)}");
npmVersion.Unity = MinimumUnityVersion;
npmPackage.Versions[npmVersion.Version] = npmVersion;
bool hasDependencyErrors = false;
foreach (var deps in netstd20Dependency.Packages)
{
var depsId = deps.Id.ToLowerInvariant();
if (!_registry.TryGetValue(deps.Id, out var packageEntryDep))
{
LogError($"The package `{packageIdentity}` has a dependency on `{deps.Id}` which is not in the registry. You must add this dependency to the registry.json file.");
hasDependencyErrors = true;
}
else if (packageEntryDep.Ignored)
{
// A package that is ignored is not declared as an explicit dependency
continue;
}
else if (!deps.VersionRange.IsSubSetOrEqualTo(packageEntryDep.Version))
{
LogError($"The version range `{deps.VersionRange}` for the dependency `{deps.Id}` for the package `{packageIdentity}` doesn't match the range allowed from the registry.json: `{packageEntryDep.Version}`");
hasDependencyErrors = true;
}
// Otherwise add the package as a dependency
npmVersion.Dependencies.Add($"{UnityScope}.{depsId}", deps.VersionRange.MinVersion.ToString());
}
// If we don't have any dependencies error, generate the package
if (!hasDependencyErrors)
{
await ConvertNuGetToUnityPackageIfDoesNotExist(packageIdentity, npmPackageInfo, npmVersion, packageMeta);
npmPackage.Time[npmCurrentVersion] = packageMeta.Published?.UtcDateTime ?? GetUnityPackageFileInfo(packageIdentity, npmVersion).CreationTimeUtc;
// Copy repository info if necessary
if (update)
{
npmPackage.Repository = npmVersion.Repository?.Clone();
}
}
}
}
}
/// <summary>
/// Creates a Nuget package from a SmartInk Package
/// </summary>
/// <param name="package">Package to use for Nuget creation</param>
/// <param name="destination">File handle for saving the Nuget package</param>
public async Task PublishPackageAsync(ISmartInkPackage package, IStorageFile destination)
{
if (package == null)
{
throw new ArgumentNullException($"{nameof(package)} cannot be null");
}
if (destination == null)
{
throw new ArgumentNullException($"{nameof(destination)} cannot be null");
}
Debug.WriteLine($"Publish package");
ManifestMetadata metadata = new ManifestMetadata()
{
Title = $"{package.Name}",
Owners = new string[] { "jabj" },
Authors = new string[] { "mauvo" },
Version = new NuGet.Versioning.NuGetVersion(new Version(package.Version)),
Id = $"SmartInk.{package.Name}",
Description = $"{package.Description}",
MinClientVersionString = "3.3.0"
};
NuGet.Frameworks.NuGetFramework targetFramework = new NuGet.Frameworks.NuGetFramework(new NuGet.Frameworks.NuGetFramework(".NETStandard2.0"));
IEnumerable <NuGet.Packaging.Core.PackageDependency> packages = new NuGet.Packaging.Core.PackageDependency[] { new NuGet.Packaging.Core.PackageDependency("NETStandard.Library", new NuGet.Versioning.VersionRange(new NuGet.Versioning.NuGetVersion(2, 0, 0))) };
var dependencyGroup = new PackageDependencyGroup(targetFramework, packages);
metadata.DependencyGroups = new PackageDependencyGroup[] { dependencyGroup };
PackageBuilder builder = new PackageBuilder();
builder.Populate(metadata);
builder.ContentFiles.Add(new ManifestContentFiles()
{
Include = $"**/SmartInkPackages/*", CopyToOutput = "true", Flatten = "false", BuildAction = "None"
});
builder.ContentFiles.Add(new ManifestContentFiles()
{
Include = $"**/SmartInkPackages/{package.Name}/*", CopyToOutput = "true", Flatten = "false", BuildAction = "None"
});
builder.ContentFiles.Add(new ManifestContentFiles()
{
Include = $"**/SmartInkPackages/{package.Name}/Model/*", CopyToOutput = "true", Flatten = "false", BuildAction = "None"
});
builder.ContentFiles.Add(new ManifestContentFiles()
{
Include = $"**/SmartInkPackages/{package.Name}/Icons/*", CopyToOutput = "true", Flatten = "false", BuildAction = "None"
});
var root = $"{_provider.RootFolderPath}\\{package.Name}\\";
List <ManifestFile> manifestFiles = new List <ManifestFile>();
var rootFolder = await StorageFolder.GetFolderFromPathAsync(root);
var files = await rootFolder.GetFilesAsync(Windows.Storage.Search.CommonFileQuery.OrderByName);
foreach (var file in files)
{
ManifestFile manifestFile = new ManifestFile();
manifestFile.Source = file.Path;
manifestFile.Target = $"contentFiles\\cs\\uap10.0\\SmartInkPackages{file.Path.Replace(_provider.RootFolderPath, "")}";
manifestFiles.Add(manifestFile);
}
builder.PopulateFiles(root, manifestFiles);
using (var fileaccess = await destination.OpenAsync(FileAccessMode.ReadWrite))
{
Debug.WriteLine($"Publish package: {builder.ToString()}");
var stream = fileaccess.AsStreamForWrite();
builder.Save(stream);
await stream.FlushAsync();
}
}
public async Task GetDependenciesAsync_WhenPackageIsSelectedWithAssetTargetFallback_AndLegacyDependencyResolutionVariableIsSpecified_CorrectDependenciesAreSelected(string envValue, bool areDependenciesSelected)
{
// Arrange
var testLogger = new TestLogger();
var cacheContext = new SourceCacheContext();
var findResource = new Mock <FindPackageByIdResource>();
var wrapper = new TestEnvironmentVariableReader(new Dictionary <string, string>
{
{ "NUGET_USE_LEGACY_ASSET_TARGET_FALLBACK_DEPENDENCY_RESOLUTION", envValue }
});
var net472 = FrameworkConstants.CommonFrameworks.Net472;
var net60 = FrameworkConstants.CommonFrameworks.Net60;
var inputFramework = new AssetTargetFallbackFramework(net60, new List <NuGetFramework> {
net472
});
var packageDependencyGroups = new List <PackageDependencyGroup>();
var net472Group = new PackageDependencyGroup(net472, new PackageDependency[] { new PackageDependency("full.framework", VersionRange.Parse("1.0.0")) });
packageDependencyGroups.Add(net472Group);
findResource.Setup(s => s.GetDependencyInfoAsync(
It.IsAny <string>(),
It.IsAny <NuGetVersion>(),
It.IsAny <SourceCacheContext>(),
It.IsAny <ILogger>(),
It.IsAny <CancellationToken>()))
.ReturnsAsync(new FindPackageByIdDependencyInfo(
new PackageIdentity("x", NuGetVersion.Parse("1.0.0-beta")),
packageDependencyGroups,
Enumerable.Empty <FrameworkSpecificGroup>()));
var source = new Mock <SourceRepository>();
source.Setup(s => s.GetResourceAsync <FindPackageByIdResource>())
.ReturnsAsync(findResource.Object);
source.SetupGet(s => s.PackageSource)
.Returns(new PackageSource("http://test/index.json"));
var provider = new SourceRepositoryDependencyProvider(
source.Object,
testLogger,
cacheContext,
ignoreFailedSources: true,
ignoreWarning: true,
fileCache: null,
isFallbackFolderSource: false,
wrapper);
// Act
var library = await provider.GetDependenciesAsync(
new LibraryIdentity("x", NuGetVersion.Parse("1.0.0-beta"), LibraryType.Package),
inputFramework,
cacheContext,
testLogger,
CancellationToken.None);
// Assert
if (areDependenciesSelected)
{
library.Dependencies.Should().HaveCount(1);
var dependencies = library.Dependencies.Single();
dependencies.Name.Should().Be("full.framework");
}
else
{
library.Dependencies.Should().HaveCount(0);
}
}
private void AddFlattennedPackageDependency(
PackageDependencyGroup dependencyGroup,
Packaging.Core.PackageDependency packageDependency,
StringBuilder builder)
{
if (builder.Length > 0)
{
builder.Append("|");
}
builder.Append(packageDependency.Id);
builder.Append(":");
if (!packageDependency.VersionRange.Equals(VersionRange.All))
{
builder.Append(packageDependency.VersionRange?.ToString("S", new VersionRangeFormatter()));
}
AddFlattenedFrameworkDependency(dependencyGroup, builder);
}
private void AddFlattenedFrameworkDependency(PackageDependencyGroup dependencyGroup, StringBuilder builder)
{
if (!SpecialFrameworks.Contains(dependencyGroup.TargetFramework))
{
try
{
builder.Append(":");
builder.Append(dependencyGroup.TargetFramework?.GetShortFolderName());
}
catch (FrameworkException)
{
// ignoring FrameworkException on purpose - we don't want the job crashing
// whenever someone uploads an unsupported framework
}
}
}
public EditablePackageDependencySet(PackageDependencyGroup packageDependencySet)
{
_targetFramework = packageDependencySet.TargetFramework;
Dependencies = new ObservableCollection <PackageDependency>(packageDependencySet.Packages);
}
public async Task Command_ReleaseCommand_MultipleNewVersions_EachTFMTakesCorrectVersion()
{
using (var workingDir = new TestFolder())
{
// Arrange
var testPackageA = new TestNupkg()
{
Nuspec = new TestNuspec()
{
Id = "a",
Version = "1.0.0"
}
};
var depGroup1 = new PackageDependencyGroup(NuGetFramework.Parse("net45"), new[] {
new PackageDependency("b", VersionRange.Parse("1.0.0"))
});
var depGroup2 = new PackageDependencyGroup(NuGetFramework.Parse("net46"), new[] {
new PackageDependency("b", VersionRange.Parse("2.0.0"))
});
testPackageA.Nuspec.Dependencies.Add(depGroup1);
testPackageA.Nuspec.Dependencies.Add(depGroup2);
var testPackageB1 = new TestNupkg()
{
Nuspec = new TestNuspec()
{
Id = "b",
Version = "1.0.0"
}
};
var testPackageB2 = new TestNupkg()
{
Nuspec = new TestNuspec()
{
Id = "b",
Version = "2.0.0"
}
};
var testPackageB3 = new TestNupkg()
{
Nuspec = new TestNuspec()
{
Id = "b",
Version = "0.1.0"
}
};
var testPackageB4 = new TestNupkg()
{
Nuspec = new TestNuspec()
{
Id = "b",
Version = "9.0.0"
}
};
var zipFileA = testPackageA.Save(workingDir.Root);
var zipFileB1 = testPackageB1.Save(workingDir.Root);
var zipFileB2 = testPackageB2.Save(workingDir.Root);
var log = new TestLogger();
// Act
var exitCode = await Program.MainCore(new[] { "release", workingDir.Root, "-r", "beta" }, log);
var nuspecA = GetNuspec(Path.Combine(workingDir.Root, "a.1.0.0-beta.nupkg"));
var dependencyBNet45 = nuspecA.GetDependencyGroups().Single(e => e.TargetFramework == NuGetFramework.Parse("net45")).Packages.Single(e => e.Id == "b");
var dependencyBNet46 = nuspecA.GetDependencyGroups().Single(e => e.TargetFramework == NuGetFramework.Parse("net46")).Packages.Single(e => e.Id == "b");
// Assert
Assert.Equal(0, exitCode);
Assert.Equal("1.0.0-beta", dependencyBNet45.VersionRange.ToLegacyShortString());
Assert.Equal("2.0.0-beta", dependencyBNet46.VersionRange.ToLegacyShortString());
}
}
private void BuildNuSpecManifest_After(object sender, BuildNuSpecManifestEventArgs e)
{
// Change the name
e.Manifest.Metadata.Title = "Kentico Page Builder Containers";
e.Manifest.Metadata.SetProjectUrl("https://github.com/KenticoDevTrev/PageBuilderContainers");
e.Manifest.Metadata.SetIconUrl("https://www.hbs.net/HBS/media/Favicon/favicon-96x96.png");
e.Manifest.Metadata.Tags = "Kentico MVC Page Builder Containers";
e.Manifest.Metadata.Id = "PageBuilderContainers.Kentico";
e.Manifest.Metadata.ReleaseNotes = "Release for Kentico Xperience 13";
// Add nuget dependencies
// Add dependencies
List <PackageDependency> NetStandardDependencies = new List <PackageDependency>()
{
new PackageDependency("Kentico.Xperience.Libraries", new VersionRange(new NuGetVersion("13.0.0")), new string[] { }, new string[] { "Build", "Analyzers" }),
new PackageDependency("PageBuilderContainers.Kentico.Base", new VersionRange(new NuGetVersion("13.0.1")), new string[] { }, new string[] { "Build", "Analyzers" })
};
PackageDependencyGroup PackageGroup = new PackageDependencyGroup(new NuGet.Frameworks.NuGetFramework(".NETStandard2.0"), NetStandardDependencies);
e.Manifest.Metadata.DependencyGroups = new PackageDependencyGroup[] { PackageGroup };
// Add in Designer.cs and .cs files since really hard to include these in class library due to depenencies
string BaseDir = HttpContext.Current.Server.MapPath("~").Trim('\\');
e.Manifest.Files.AddRange(new ManifestFile[] {
new ManifestFile()
{
Source = BaseDir + "\\CMSModules\\PageBuilderContainers\\Controls\\PageBuilderContainers\\General.ascx.cs",
Target = "\\Content\\CMSModules\\PageBuilderContainers\\Controls\\PageBuilderContainers\\General.ascx.cs",
},
new ManifestFile()
{
Source = BaseDir + "\\CMSModules\\PageBuilderContainers\\Controls\\PageBuilderContainers\\General.ascx.designer.cs",
Target = "\\Content\\CMSModules\\PageBuilderContainers\\Controls\\PageBuilderContainers\\General.ascx.designer.cs",
},
new ManifestFile()
{
Source = BaseDir + "\\CMSModules\\PageBuilderContainers\\Controls\\PageBuilderContainers\\PageBuilderContainerCode.ascx.cs",
Target = "\\Content\\CMSModules\\PageBuilderContainers\\Controls\\PageBuilderContainers\\PageBuilderContainerCode.ascx.cs",
},
new ManifestFile()
{
Source = BaseDir + "\\CMSModules\\PageBuilderContainers\\Controls\\PageBuilderContainers\\PageBuilderContainerCode.ascx.designer.cs",
Target = "\\Content\\CMSModules\\PageBuilderContainers\\Controls\\PageBuilderContainers\\PageBuilderContainerCode.ascx.designer.cs",
},
new ManifestFile()
{
Source = BaseDir + "\\CMSModules\\PageBuilderContainers\\UI\\PageBuilderContainers\\Container_Edit_General.aspx.cs",
Target = "\\Content\\CMSModules\\PageBuilderContainers\\UI\\PageBuilderContainers\\Container_Edit_General.aspx.cs",
},
new ManifestFile()
{
Source = BaseDir + "\\CMSModules\\PageBuilderContainers\\UI\\PageBuilderContainers\\Container_Edit_General.aspx.designer.cs",
Target = "\\Content\\CMSModules\\PageBuilderContainers\\UI\\PageBuilderContainers\\Container_Edit_General.aspx.designer.cs",
},
new ManifestFile()
{
Source = BaseDir + "\\CMSModules\\PageBuilderContainers\\UI\\PageBuilderContainers\\Container_New.aspx.cs",
Target = "\\Content\\CMSModules\\PageBuilderContainers\\UI\\PageBuilderContainers\\Container_New.aspx.cs",
},
new ManifestFile()
{
Source = BaseDir + "\\CMSModules\\PageBuilderContainers\\UI\\PageBuilderContainers\\Container_New.aspx.designer.cs",
Target = "\\Content\\CMSModules\\PageBuilderContainers\\UI\\PageBuilderContainers\\Container_New.aspx.designer.cs",
}
});
}
public async Task Command_ReleaseCommand_Label()
{
using (var workingDir = new TestFolder())
{
// Arrange
var testPackageA = new TestNupkg()
{
Nuspec = new TestNuspec()
{
Id = "a",
Version = "1.0.0-beta.1.2"
}
};
var depGroup = new PackageDependencyGroup(NuGetFramework.Parse("net45"), new[] {
new PackageDependency("b", VersionRange.Parse("2.0.0-alpha")),
new PackageDependency("c", VersionRange.Parse("[1.0.0-beta]"))
});
testPackageA.Nuspec.Dependencies.Add(depGroup);
var testPackageB = new TestNupkg()
{
Nuspec = new TestNuspec()
{
Id = "b",
Version = "2.0.0-alpha"
}
};
var testPackageC = new TestNupkg()
{
Nuspec = new TestNuspec()
{
Id = "c",
Version = "1.0.0-beta"
}
};
var zipFileA = testPackageA.Save(workingDir.Root);
var zipFileB = testPackageB.Save(workingDir.Root);
var zipFileC = testPackageC.Save(workingDir.Root);
var log = new TestLogger();
// Act
var exitCode = await Program.MainCore(new[] { "release", workingDir.Root, "--label", "rc.1" }, log);
var nuspecA = GetNuspec(Path.Combine(workingDir.Root, "a.1.0.0-rc.1.nupkg"));
var nuspecB = GetNuspec(Path.Combine(workingDir.Root, "b.2.0.0-rc.1.nupkg"));
var nuspecC = GetNuspec(Path.Combine(workingDir.Root, "c.1.0.0-rc.1.nupkg"));
// Assert
Assert.Equal(0, exitCode);
Assert.Equal("1.0.0-rc.1", nuspecA.GetVersion().ToString());
Assert.Equal("2.0.0-rc.1", nuspecB.GetVersion().ToString());
Assert.Equal("1.0.0-rc.1", nuspecC.GetVersion().ToString());
Assert.Equal("2.0.0-rc.1", nuspecA.GetDependencyGroups().Single().Packages.Single(e => e.Id == "b").VersionRange.ToLegacyShortString());
Assert.Equal("[1.0.0-rc.1]", nuspecA.GetDependencyGroups().Single().Packages.Single(e => e.Id == "c").VersionRange.ToLegacyShortString());
}
}
public static FrameworkGroup ToFrameworkGroup(this PackageDependencyGroup dependency) =>
new FrameworkGroup(dependency.TargetFramework.ToFramework(),
dependency.Packages.Select(d => new PackageIdentity(d.Id, d.VersionRange.MinVersion.ToPackageVersion())));
private static JProperty WritePackageDependencySet(PackageDependencyGroup item)
{
return(new JProperty(
item.TargetFramework?.ToString() ?? "*",
WriteObject(item.Packages, WritePackageDependency)));
}
void AddDependenciesToSearchMetadata (params PackageDependency [] dependencies)
{
var dependencyGroup = new PackageDependencyGroup (
new NuGetFramework ("any"),
dependencies);
packageSearchMetadata.DependencySetsList.Add (dependencyGroup);
}
