public void ContructorThrowsWhenMetadataIsNull()
{
var exception = Assert.Throws<ArgumentNullException>(() =>
{
var manifest = new Manifest(null);
});
}
public void FilesListIsEmptyByDefault()
{
var manifest = new Manifest(new ManifestMetadata());
Assert.NotNull(manifest.Files);
Assert.Empty(manifest.Files);
}
public void CreateSpec()
{
if (!Directory.Exists(_outputPath))
Directory.CreateDirectory(_outputPath);
var dependencies = new List<ManifestDependencySet>();
if (File.Exists(Path.Combine(_settings.ProjectPath, "packages.config")) && !NuspecDefinition.IsToolsOnly)
{
dependencies = AnalyzePackagesConfig();
}
var spec = new Manifest();
var meta = RetrieveMetaData(dependencies);
LoadAdditionalMetadata(meta);
spec.Metadata = meta;
LoadManifestFile(spec);
spec.Files = NuspecDefinition.ManifestFiles;
spec.OrganizeManifest(NuspecDefinition);
spec.Metadata.DependencySets.ToList().ForEach(ds =>
{
var t = ds.Dependencies.FirstOrDefault(d => d.Id == "OCS.Package.Util");
if (t != null)
{
ds.Dependencies.Remove(t);
}
});
BuildPackage(spec);
}
public void ReturnsErrorIfIdTooLong()
{
Manifest m = new Manifest()
{
Metadata = new ManifestMetadata()
{
Id = new String('a', 101),
Version = "1.0.0"
}
};
Assert.Equal(new[] { Strings.Manifest_IdTooLong }, GetErrors(m));
}
public void ReturnsErrorIfIdNotPresent()
{
Manifest m = new Manifest()
{
Metadata = new ManifestMetadata()
{
Id = null,
Version = "1.0.0"
}
};
Assert.Equal(new[] { Strings.Manifest_MissingId }, GetErrors(m));
}
public void ReturnsErrorIfIdInvalid()
{
Manifest m = new Manifest()
{
Metadata = new ManifestMetadata()
{
Id = "not a valid id",
Version = "1.0.0"
}
};
Assert.Equal(new[] { String.Format(Strings.Manifest_InvalidId, "not a valid id") }, GetErrors(m));
}
public void ReturnsErrorIfProjectUrlInvalid()
{
Manifest m = new Manifest()
{
Metadata = new ManifestMetadata()
{
Id = "valid",
Version = "1.0.0",
ProjectUrl = "http://a b c d"
}
};
Assert.Equal(new[] { Strings.Manifest_InvalidUrl }, GetErrors(m));
}
public void Save()
{
var id = "TestId";
var version = new SemanticVersion("0.1.0");
var authors = new string[] { "Alice", "Bob" };
var manifest = new Manifest(new ManifestMetadata
{
Id = id,
Version = version,
Authors = authors
});
using (var mem = new MemoryStream())
{
manifest.Save(mem);
mem.Position = 0;
var xdoc = XDocument.Load(mem);
var ns = xdoc.Root.GetDefaultNamespace();
var xElemPackage = xdoc.Root;
Assert.Equal("package", xElemPackage.Name.LocalName);
Assert.Equal(1, xElemPackage.Elements().Count());
var xElemMetadata = xElemPackage.Elements().Single();
Assert.Equal("metadata", xElemMetadata.Name.LocalName);
Assert.Equal(5, xElemMetadata.Elements().Count());
var xElemId = xElemMetadata.Element(ns + "id");
Assert.NotNull(xElemId);
Assert.Equal(id, xElemId.Value);
var xElemVersion = xElemMetadata.Element(ns + "version");
Assert.NotNull(xElemVersion);
Assert.Equal(version.ToString(), xElemVersion.Value);
var xElemRequireLicense = xElemMetadata.Element(ns + "requireLicenseAcceptance");
Assert.NotNull(xElemRequireLicense);
Assert.Equal("false", xElemRequireLicense.Value);
var xElemAuthors = xElemMetadata.Element(ns + "authors");
Assert.NotNull(xElemAuthors);
Assert.Equal(string.Join(",", authors), xElemAuthors.Value);
var xElemOwners = xElemMetadata.Element(ns + "owners");
Assert.NotNull(xElemOwners);
Assert.Equal(string.Join(",", authors), xElemOwners.Value);
}
}
public NuSpecFile(string filename)
{
_filename = filename;
_info = new FileInfo(filename);
using (var fs = File.Open(filename, FileMode.Open))
{
_manifest = Manifest.ReadFrom(fs, false);
}
if (Manifest.Files == null)
{
Manifest.Files = new List<ManifestFile>();
}
if (_manifest.Metadata.DependencySets == null)
{
_manifest.Metadata.DependencySets = new List<ManifestDependencySet>();
}
}
/// <summary>
/// Safely load Nupkg manifest data and file contents list from an untrusted zip file stream.
/// May modify the .Position of the stream.
/// </summary>
public Nupkg(Stream stream, bool leaveOpen)
{
if (stream == null)
{
throw new ArgumentNullException("stream");
}
if (!stream.CanSeek)
{
var originalStream = stream;
stream = new MemoryStream(originalStream.ReadAllBytes(), writable: false);
if (!leaveOpen)
{
originalStream.Dispose();
}
}
_stream = stream;
_archive = new ZipArchive(stream, ZipArchiveMode.Read, leaveOpen);
_manifest = SafelyLoadManifest(_archive);
}
static Manifest InitiateManifestFromAssembly(Assembly assembly, IEnumerable<PackageReference> deps){
Manifest manifest = new Manifest();
AssemblyInfo ainfo = new AssemblyInfo(assembly);
//Version
manifest.Metadata.Version = ManifestVersionFromAssembly(ainfo);
// Copyright
manifest.Metadata.Copyright = ainfo.Copyright;
// Authors
if (ainfo.Authors != null) {
manifest.Metadata.Authors = ainfo.Authors.Keys.Aggregate((key, next) => key + "," + next);
manifest.Metadata.Owners = ainfo.Authors.Keys.Aggregate((key, next) => key + "," + next);
}
// Description
manifest.Metadata.Description = ainfo.Description;
// Icon Url
if ( ainfo.IconUrl != null )
manifest.Metadata.IconUrl = ainfo.IconUrl.ToString();
// Id
manifest.Metadata.Id = ainfo.ProductTitle;
// License Url
if (ainfo.LicenseUrl != null)
manifest.Metadata.LicenseUrl = ainfo.LicenseUrl.ToString();
// Project Url
if (ainfo.ProjectUrl != null)
manifest.Metadata.ProjectUrl = ainfo.ProjectUrl.ToString();
// Tags
manifest.Metadata.Tags = ainfo.Tags;
// Title
manifest.Metadata.Title = ainfo.ProductTitle;
// Dependencies
if (deps != null) {
manifest.Metadata.DependencySets = new List<ManifestDependencySet>();
foreach (var frameworkVersion in deps.Select<PackageReference, FrameworkName>(pr => pr.TargetFramework).Distinct().ToArray()) {
NetPortableProfile npp = new NetPortableProfile("test", new FrameworkName[1]{ frameworkVersion });
ManifestDependencySet mds = new ManifestDependencySet();
mds.Dependencies = new List<ManifestDependency>();
mds.TargetFramework = npp.CustomProfileString;
manifest.Metadata.DependencySets.Add(mds);
foreach (var dep in deps.Where(d => d.TargetFramework == frameworkVersion).ToArray()) {
ManifestDependency md = new ManifestDependency();
md.Id = dep.Id;
md.Version = dep.Version.ToNormalizedString();
mds.Dependencies.Add(md);
}
}
}
return manifest;
}
public void ReturnsErrorIfVersionInvalid()
{
Manifest m = new Manifest()
{
Metadata = new ManifestMetadata()
{
Id = "valid",
Version = "1 2 3",
}
};
Assert.Equal(new[] { String.Format(Strings.Manifest_InvalidVersion, "1 2 3") }, GetErrors(m));
}
private static Version SetPackageVersion(Options options, Manifest m)
{
Version v2;
if (options.Version != null)
{
if (options.Version.StartsWith("+"))
{
Version v = Version.Parse(m.Metadata.Version);
Version vinc = Version.Parse(options.Version.Substring(1));
v2 = new Version(v.Major + vinc.Major, v.Minor + vinc.Minor, v.Build + vinc.Build, 0);
}
else
{
v2 = Version.Parse(options.Version);
}
}
else
{
Assembly asm = FindAssembly(options, m);
v2 = asm.GetName().Version;
}
m.Metadata.Version = v2.ToString();
using (FileStream fileStream = File.Open(options.NuSpec, FileMode.Truncate))
m.Save(fileStream, true);
return v2;
}
public void ReturnsErrorIfDependencySetContainsInvalidTargetFramework()
{
Manifest m = new Manifest()
{
Metadata = new ManifestMetadata()
{
Id = "valid",
Version = "1.0.0",
DependencySets = new List<ManifestDependencySet>()
{
new ManifestDependencySet() {
TargetFramework = "net40-client-full-awesome-unicorns",
Dependencies = new List<ManifestDependency>() {
new ManifestDependency() {
Id = "a.b.c",
Version = "1.0-alpha"
}
}
}
}
}
};
Assert.Equal(new[] { String.Format(Strings.Manifest_InvalidTargetFramework, "net40-client-full-awesome-unicorns") }, GetErrors(m));
}
public static IEnumerable<ValidationResult> Validate(Manifest manifest)
{
return Validate(manifest.Metadata);
}
/// <summary>
/// Exports the page.
/// </summary>
/// <param name="page">The page.</param>
/// <param name="isRecursive">if set to <c>true</c> [should export children].</param>
/// <returns>a <see cref="T:System.IO.MemoryStream"/> of the exported page package.</returns>
public MemoryStream ExportPage( Page page, bool isRecursive )
{
// Create a temp directory to hold package contents in staging area
string packageId = Guid.NewGuid().ToString();
var packageDirectory = CreatePackageDirectory( page.InternalName, packageId );
var webRootPath = HttpContext.Current.Server.MapPath( "~" );
// Create a manifest for this page export...
Manifest manifest = new Manifest();
manifest.Metadata = new ManifestMetadata();
manifest.Metadata.Authors = "PageExport";
manifest.Metadata.Version = "0.0";
manifest.Metadata.Id = packageId;
manifest.Metadata.Description = ( string.IsNullOrEmpty( page.Description ) ) ? "a page export" : page.Description;
manifest.Files = new List<ManifestFile>();
// Generate the JSON from model data and write it to disk, then add it to the manifest
var json = GetJson( page, isRecursive );
using ( var file = new StreamWriter( Path.Combine( packageDirectory.FullName, "export.json" ) ) )
{
file.Write( json );
}
AddToManifest( manifest, packageDirectory.FullName, webRootPath, "export.json", SearchOption.TopDirectoryOnly );
// * Find out from `page` which Blocks need to be packaged up (recursively if ExportChildren box is checked)
// * Grab asset folders for each Block's code file uniquely (Scripts, Assets, CSS folders)
// * Add them to the package manifest
var blockTypes = new Dictionary<Guid, BlockType>();
var uniqueDirectories = new Dictionary<string, string>();
FindUniqueBlockTypesAndDirectories( page, isRecursive, blockTypes, uniqueDirectories );
foreach ( var blockType in blockTypes.Values )
{
var sourcePath = HttpContext.Current.Server.MapPath( blockType.Path );
var directory = sourcePath.Substring( 0, sourcePath.LastIndexOf( Path.DirectorySeparatorChar ) );
var fileName = Path.GetFileNameWithoutExtension( sourcePath );
var pattern = string.Format( "{0}.*", fileName );
AddToManifest( manifest, directory, webRootPath, pattern, SearchOption.TopDirectoryOnly );
}
// Second pass through blocks. Determine which folders (by convention) need to be added
// to the package manifest.
foreach ( var dir in uniqueDirectories.Keys )
{
var sourcePath = HttpContext.Current.Server.MapPath( dir );
// Are there any folders present named "CSS", "Scripts" or "Assets"?
AddToManifest( manifest, Path.Combine( sourcePath, "CSS" ), webRootPath );
AddToManifest( manifest, Path.Combine( sourcePath, "Scripts" ), webRootPath );
AddToManifest( manifest, Path.Combine( sourcePath, "Assets" ), webRootPath );
}
// Save the manifest as "pageexport.nuspec" in the temp folder
string basePath = packageDirectory.FullName;
string manifestPath = Path.Combine( basePath, "pageexport.nuspec" );
using ( Stream fileStream = File.Create( manifestPath ) )
{
manifest.Save( fileStream );
}
// Create a NuGet package from the manifest and 'save' it to a memory stream for the consumer...
// BTW - don't use anything older than nuget 2.1 due to Manifest bug (http://nuget.codeplex.com/workitem/2813)
// which will cause the PackageBuilder constructor to fail due to <Files> vs <files> being in the manifest.
PackageBuilder packageBuilder = new PackageBuilder( manifestPath, basePath, NullPropertyProvider.Instance, false );
var outputStream = new MemoryStream();
packageBuilder.Save( outputStream );
// Clean up staging area
packageDirectory.Delete( recursive: true );
return outputStream;
}
private Manifest CreateManifest()
{
Manifest manifest;
ManifestMetadata manifestMetadata;
if (!string.IsNullOrEmpty(InputFileName))
{
using (var stream = File.OpenRead(InputFileName))
{
manifest = Manifest.ReadFrom(stream);
}
if (manifest.Metadata == null)
{
manifest = new Manifest(new ManifestMetadata(), manifest.Files);
}
}
else
{
manifest = new Manifest(new ManifestMetadata());
}
manifestMetadata = manifest.Metadata;
manifestMetadata.UpdateMember(x => x.Authors, Authors?.Split(';'));
manifestMetadata.UpdateMember(x => x.Copyright, Copyright);
manifestMetadata.UpdateMember(x => x.DependencySets, GetDependencySets());
manifestMetadata.UpdateMember(x => x.Description, Description);
manifestMetadata.DevelopmentDependency |= DevelopmentDependency;
manifestMetadata.UpdateMember(x => x.FrameworkAssemblies, GetFrameworkAssemblies());
manifestMetadata.UpdateMember(x => x.IconUrl, IconUrl != null ? new Uri(IconUrl) : null);
manifestMetadata.UpdateMember(x => x.Id, Id);
manifestMetadata.UpdateMember(x => x.Language, Language);
manifestMetadata.UpdateMember(x => x.LicenseUrl, new Uri(LicenseUrl));
manifestMetadata.UpdateMember(x => x.MinClientVersionString, MinClientVersion);
manifestMetadata.UpdateMember(x => x.Owners, Owners?.Split(';'));
manifestMetadata.UpdateMember(x => x.ProjectUrl, ProjectUrl != null ? new Uri(ProjectUrl) : null);
manifestMetadata.AddRangeToMember(x => x.PackageAssemblyReferences, GetReferenceSets());
manifestMetadata.UpdateMember(x => x.ReleaseNotes, ReleaseNotes);
manifestMetadata.RequireLicenseAcceptance |= RequireLicenseAcceptance;
manifestMetadata.UpdateMember(x => x.Summary, Summary);
manifestMetadata.UpdateMember(x => x.Tags, Tags);
manifestMetadata.UpdateMember(x => x.Title, Title);
manifestMetadata.UpdateMember(x => x.Version, Version != null ? new NuGetVersion(Version) : null);
manifest.AddRangeToMember(x => x.Files, GetManifestFiles());
return manifest;
}
public void ReturnsErrorIfDependencySetContainsInvalidId()
{
Manifest m = new Manifest()
{
Metadata = new ManifestMetadata()
{
Id = "valid",
Version = "1.0.0",
DependencySets = new List<ManifestDependencySet>()
{
new ManifestDependencySet() {
TargetFramework = "net40",
Dependencies = new List<ManifestDependency>() {
new ManifestDependency() {
Id = "a b c",
Version = "1.0"
}
}
}
}
}
};
Assert.Equal(new[] { String.Format(Strings.Manifest_InvalidDependency, "a b c", "1.0") }, GetErrors(m));
}
private string[] GetErrors(Manifest m)
{
return ManifestValidator
.Validate(m)
.Select(r => r.ErrorMessage)
.ToArray();
}
public void ReturnsErrorIfFrameworkAssemblyReferenceContainsInvalidTargetFramework()
{
Manifest m = new Manifest()
{
Metadata = new ManifestMetadata()
{
Id = "valid",
Version = "1.0.0",
FrameworkAssemblies = new List<ManifestFrameworkAssembly>()
{
new ManifestFrameworkAssembly() {
TargetFramework = "net40-client-full-awesome-unicorns",
AssemblyName = "System.Awesome"
}
}
}
};
Assert.Equal(new[] { String.Format(Strings.Manifest_InvalidTargetFramework, "net40-client-full-awesome-unicorns") }, GetErrors(m));
}
public void NoErrorIfFrameworkAssemblyReferenceContainsEmptyTargetFramework()
{
Manifest m = new Manifest()
{
Metadata = new ManifestMetadata()
{
Id = "valid",
Version = "1.0.0",
FrameworkAssemblies = new List<ManifestFrameworkAssembly>()
{
new ManifestFrameworkAssembly() {
TargetFramework = "",
AssemblyName = "System.Awesome"
}
}
}
};
Assert.Equal(GetErrors(m).Length, 0);
}
public static string CreateManifest(List<ManifestFile> manifestFiles, string releaseNotes)
{
var manifest = new Manifest
{
Metadata = new ManifestMetadata
{
Id = Options.NuspecId,
Version = "0.0.0", //overloaded by nuget pack cmd line parameters
Authors = "Sitecore NuGetPack Runner",
Description = string.Format("Sitecore NuGet Package, built on {0}", DateTime.Now.ToString("HH:mm dd/MM/yyyy")),
ReleaseNotes = releaseNotes
},
Files = manifestFiles
};
var manifestFilePath = Path.Combine(Options.TargetDir, Options.NuspecId + NuspecExt);
using (var fsManifest = new FileStream(manifestFilePath, FileMode.Create))
{
manifest.Save(fsManifest, true);
}
return manifestFilePath;
}
private void LoadManifestFile(Manifest manifest)
{
if (!_hasAssembly)
return;
_assembly.GetReferencedAssemblies().ToList().ForEach(references =>
{
if (manifest.Metadata.DependencySets.Exists(s => s.Dependencies.Exists(d => d.Id == references.Name)))
{
return;
}
Assembly ass;
try
{
ass = Assembly.Load(references);
}
catch (Exception)
{
ass = Assembly.LoadFrom(Path.Combine(_settings.OutputPath, string.Format("{0}.{1}", references.Name, "dll")));
}
if (ass == null)
return;
if (CheckAssemblyAndIncludeIfReferenced(ass))
{
ass.GetReferencedAssemblies().ToList().ForEach(dependent =>
{
if (manifest.Metadata.DependencySets.Exists(s => s.Dependencies.Exists(d => d.Id == dependent.Name)))
{
return;
}
try
{
var depAss = Assembly.Load(dependent);
CheckAssemblyAndIncludeIfReferenced(depAss);
}
catch (Exception)
{
}
});
}
});
CheckAssemblyAndIncludeIfReferenced(_assembly);
}
private static Assembly FindAssembly(Options options, Manifest manifest)
{
string id = manifest.Metadata.Id;
ManifestFile asmf = manifest.Files.FirstOrDefault(f => Path.GetFileName(f.Source) == id + ".exe");
if (asmf == null)
return null;
string fullPath = Path.Combine(Path.GetDirectoryName(options.NuSpec), asmf.Source);
return Assembly.ReflectionOnlyLoadFrom(fullPath);
}
private bool IsDifferent(Manifest newManifest)
{
if (!File.Exists(OutputFileName))
return true;
var oldSource = File.ReadAllText(OutputFileName);
var newSource = "";
using (var stream = new MemoryStream())
{
newManifest.Save(stream);
stream.Seek(0, SeekOrigin.Begin);
newSource = Encoding.UTF8.GetString(stream.ToArray());
}
return oldSource != newSource;
}
public void NoErrorIfDependencySetContainsEmptyTargetFramework()
{
Manifest m = new Manifest()
{
Metadata = new ManifestMetadata()
{
Id = "valid",
Version = "1.0.0",
DependencySets = new List<ManifestDependencySet>()
{
new ManifestDependencySet() {
TargetFramework = "",
Dependencies = new List<ManifestDependency>() {
new ManifestDependency() {
Id = "a.b.c",
Version = "1.0-alpha"
}
}
}
}
}
};
Assert.Equal(GetErrors(m).Length, 0);
}
/// <summary>
/// Add the given directories files (matching the given file filter and search options)
/// to the manifest.
/// </summary>
/// <param name="manifest">A NuGet Manifest</param>
/// <param name="directory">the directory containing the file(s)</param>
/// <param name="webRootPath">the physical path to the app's webroot</param>
/// <param name="filterPattern"> A file filter pattern such as *.* or *.cs</param>
/// <param name="searchOption">A <see cref="T:System.IO.SearchOption"/> search option to define the scope of the search</param>
private void AddToManifest( Manifest manifest, string directory, string webRootPath,
string filterPattern = "*.*", SearchOption searchOption = SearchOption.AllDirectories )
{
if ( !Directory.Exists( directory ) )
{
return;
}
// In our trivial case, the files we're adding need to have a target folder under the "content\"
// folder and the source path suffix will be the relative path to the file's physical location.
// ex: `Blocks\Foo\Foo.ascx` and `App_Data\PackageStaging\{PageName}_{Guid}\export.json`
var files = from file in Directory.EnumerateFiles( directory, filterPattern, searchOption )
let pathSuffix = file.Substring( webRootPath.Length )
select new ManifestFile()
{
Source = Path.Combine( "..", "..", "..", pathSuffix ),
Target = Path.Combine( "content", pathSuffix )
};
manifest.Files.AddRange( files );
}
private static string CreatePackage(Options options, Manifest m)
{
string expectedPackage = string.Format("{0}.{1}.nupkg", m.Metadata.Id, m.Metadata.Version);
TryDelete(expectedPackage);
bool p = RunProcess(options.NugetExe, string.Format("pack \"{0}\"", options.NuSpec));
return p && File.Exists(expectedPackage) ? expectedPackage : null;
//.nuget\NuGet.exe pack NewOrder\NewOrder.nuspec
}
internal static void Validate(Manifest manifest)
{
var results = new List<ValidationResult>();
// Run all data annotations validations
TryValidate(manifest.Metadata, results);
TryValidate(manifest.Files, results);
if (manifest.Metadata.DependencySets != null)
{
TryValidate(manifest.Metadata.DependencySets.SelectMany(d => d.Dependencies), results);
}
TryValidate(manifest.Metadata.ReferenceSets, results);
if (results.Any())
{
string message = String.Join(Environment.NewLine, results.Select(r => r.ErrorMessage));
throw new ValidationException(message);
}
// Validate additional dependency rules dependencies
ValidateDependencySets(manifest.Metadata);
}
private void BuildPackage(Manifest manifest)
{
var builder = new PackageBuilder();
builder.Populate(manifest.Metadata);
builder.PopulateFiles(_outputPath, manifest.Files);
var file = Path.Combine(_outputPath, string.Format("{0}.{1}.nupkg", builder.Id, builder.Version));
var localRepo = new LocalPackageRepository(_outputPath, NuspecDefinition.PackageSource);
if (File.Exists(file))
{
File.Delete(file);
}
using (var buildFile = File.Open(file, FileMode.OpenOrCreate))
{
builder.Save(buildFile);
buildFile.Flush();
buildFile.Close();
}
var package = localRepo.GetPackage(builder.Id, builder.Version);
if (NuspecDefinition.PublishPackage)
{
localRepo.PushPackage(package);
}
}
