public void ProjectFactoryInitializesPropertiesForPreprocessor()
{
// arrange
const string inputSpec = @"<?xml version=""1.0""?>
<package>
<metadata>
<id>$id$</id>
<version>$version$</version>
<description>$description$</description>
<authors>$author$</authors>
<copyright>$copyright$</copyright>
<licenseUrl>http://nuget.codeplex.com/license</licenseUrl>
<projectUrl>http://nuget.codeplex.com</projectUrl>
<tags>nuget</tags>
</metadata>
</package>";
var metadata = new ManifestMetadata
{
Id = "ProjectFactoryTest",
Version = "2.0.30619.9000",
Title = "NuGet.Test",
Description = "",
Copyright = "\x00a9 Outercurve. All rights reserved.",
Authors = "Outercurve Foundation",
};
var projectMock = new Mock<Project>();
var factory = new ProjectFactory(projectMock.Object);
// act
var author = factory.InitializeProperties(metadata);
var actual = Preprocessor.Process(inputSpec.AsStream(), factory, false);
// assert
Assert.Equal("Outercurve Foundation", author);
const string expected = @"<?xml version=""1.0""?>
<package>
<metadata>
<id>ProjectFactoryTest</id>
<version>2.0.30619.9000</version>
<description></description>
<authors>Outercurve Foundation</authors>
<copyright>© Outercurve. All rights reserved.</copyright>
<licenseUrl>http://nuget.codeplex.com/license</licenseUrl>
<projectUrl>http://nuget.codeplex.com</projectUrl>
<tags>nuget</tags>
</metadata>
</package>";
Assert.Equal(expected, actual);
}
private IPackage BuildFromProjectFile(string path)
{
var factory = new ProjectFactory(path, Properties)
{
IsTool = Tool,
Logger = Console,
Build = Build,
IncludeReferencedProjects = IncludeReferencedProjects
};
// Add the additional Properties to the properties of the Project Factory
foreach (var property in Properties)
{
if (factory.ProjectProperties.ContainsKey(property.Key))
{
Console.WriteWarning(LocalizedResourceManager.GetString("Warning_DuplicatePropertyKey"), property.Key);
}
factory.ProjectProperties[property.Key] = property.Value;
}
// Create a builder for the main package as well as the sources/symbols package
PackageBuilder mainPackageBuilder = factory.CreateBuilder(BasePath);
// Build the main package
IPackage package = BuildPackage(mainPackageBuilder);
// If we're excluding symbols then do nothing else
if (!Symbols)
{
return(package);
}
Console.WriteLine();
Console.WriteLine(LocalizedResourceManager.GetString("PackageCommandAttemptingToBuildSymbolsPackage"), Path.GetFileName(path));
factory.IncludeSymbols = true;
PackageBuilder symbolsBuilder = factory.CreateBuilder(BasePath);
symbolsBuilder.Version = mainPackageBuilder.Version;
// Get the file name for the sources package and build it
string outputPath = GetOutputPath(symbolsBuilder, symbols: true);
BuildPackage(symbolsBuilder, outputPath);
// this is the real package, not the symbol package
return(package);
}
private IPackage BuildFromProjectFile(string path)
{
var factory = new ProjectFactory(path, Properties)
{
IsTool = Tool,
Logger = Console,
Build = Build,
};
// Add the additional Properties to the properties of the Project Factory
foreach (var property in Properties)
{
factory.ProjectProperties.Add(property.Key, property.Value);
}
// Create a builder for the main package as well as the sources/symbols package
PackageBuilder mainPackageBuilder = factory.CreateBuilder(BasePath);
// Build the main package
IPackage package = BuildPackage(mainPackageBuilder);
// If we're excluding symbols then do nothing else
if (!Symbols)
{
return(package);
}
Console.WriteLine();
Console.WriteLine(NuGetResources.PackageCommandAttemptingToBuildSymbolsPackage, Path.GetFileName(path));
factory.IncludeSymbols = true;
PackageBuilder symbolsBuilder = factory.CreateBuilder(BasePath);
symbolsBuilder.Version = mainPackageBuilder.Version;
// Get the file name for the sources package and build it
string outputPath = GetOutputPath(symbolsBuilder, symbols: true);
BuildPackage(symbolsBuilder, outputPath);
// this is the real package, not the symbol package
return(package);
}
private PackageDependency CreateDependencyFromProject(Project project)
{
try
{
var projectFactory = new ProjectFactory(project);
projectFactory.Build = Build;
projectFactory.ProjectProperties = ProjectProperties;
projectFactory.BaseTargetPath = BaseTargetPath;
projectFactory.SolutionName = SolutionName;
projectFactory.BuildProject();
var builder = new PackageBuilder();
try
{
AssemblyMetadataExtractor.ExtractMetadata(builder, projectFactory.TargetPath);
}
catch
{
projectFactory.ExtractMetadataFromProject(builder);
}
projectFactory.InitializeProperties(builder);
projectFactory.ProcessNuspec(builder, null);
return(new PackageDependency(
builder.Id,
VersionUtility.ParseVersionSpec(builder.Version.ToString())));
}
catch (Exception ex)
{
var message = string.Format(
CultureInfo.InvariantCulture,
LocalizedResourceManager.GetString("Error_ProcessingNuspecFile"),
project.FullPath,
ex.Message);
throw new CommandLineException(message, ex);
}
}
private IPackage BuildFromProjectFile(string path)
{
var factory = new ProjectFactory(path, Properties)
{
IsTool = Tool,
Logger = Console,
Build = Build,
};
// Create a builder for the main package as well as the sources/symbols package
PackageBuilder mainPackageBuilder = factory.CreateBuilder(BasePath);
// Build the main package
IPackage package = BuildPackage(mainPackageBuilder);
// If we're excluding symbols then do nothing else
if (!Symbols)
{
return package;
}
Console.WriteLine();
Console.WriteLine(NuGetResources.PackageCommandAttemptingToBuildSymbolsPackage, Path.GetFileName(path));
factory.IncludeSymbols = true;
PackageBuilder symbolsBuilder = factory.CreateBuilder(BasePath);
symbolsBuilder.Version = mainPackageBuilder.Version;
// Get the file name for the sources package and build it
string outputPath = GetOutputPath(symbolsBuilder, symbols: true);
BuildPackage(symbolsBuilder, outputPath);
// this is the real package, not the symbol package
return package;
}
private IPackage BuildFromProjectFile(string path)
{
var factory = new ProjectFactory(path, Properties)
{
IsTool = Tool,
Logger = Console,
Build = Build,
IncludeReferencedProjects = IncludeReferencedProjects
};
// Add the additional Properties to the properties of the Project Factory
foreach (var property in Properties)
{
if (factory.ProjectProperties.ContainsKey(property.Key))
{
Console.WriteWarning(LocalizedResourceManager.GetString("Warning_DuplicatePropertyKey"), property.Key);
}
factory.ProjectProperties[property.Key] = property.Value;
}
// Create a builder for the main package as well as the sources/symbols package
PackageBuilder mainPackageBuilder = factory.CreateBuilder(BasePath);
// Build the main package
IPackage package = BuildPackage(mainPackageBuilder);
// If we're excluding symbols then do nothing else
if (!Symbols)
{
return package;
}
Console.WriteLine();
Console.WriteLine(LocalizedResourceManager.GetString("PackageCommandAttemptingToBuildSymbolsPackage"), Path.GetFileName(path));
factory.IncludeSymbols = true;
PackageBuilder symbolsBuilder = factory.CreateBuilder(BasePath);
symbolsBuilder.Version = mainPackageBuilder.Version;
// Get the file name for the sources package and build it
string outputPath = GetOutputPath(symbolsBuilder, symbols: true);
BuildPackage(symbolsBuilder, outputPath);
// this is the real package, not the symbol package
return package;
}
public void ProjectFactoryAppliesGlobalProperties()
{
// Arrange
var testAssembly = Assembly.GetExecutingAssembly();
var projectXml = @"<?xml version=""1.0"" encoding=""utf-8""?>
<Project ToolsVersion=""4.0"" xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
<PropertyGroup>
<ProjectGuid>{F879F274-EFA0-4157-8404-33A19B4E6AEC}</ProjectGuid>
<OutputType>Library</OutputType>
<RootNamespace>NuGet.Test</RootNamespace>
<AssemblyName>" + testAssembly.GetName().Name + @"</AssemblyName>
<TargetFrameworkProfile Condition="" '$(TargetFrameworkVersion)' == 'v4.0' "">Client</TargetFrameworkProfile>
<OutputPath>.</OutputPath> <!-- Force it to look for the assembly in the base path -->
</PropertyGroup>
<ItemGroup>
<Compile Include=""..\..\Dummy.cs"">
<Link>Dummy.cs</Link>
</Compile>
</ItemGroup>
<Import Project=""$(MSBuildToolsPath)\Microsoft.CSharp.targets"" />
<Import Project=""C:\DoesNotExist.targets"" Condition="" '$(MyGlobalProperty)' != 'true' "" />
</Project>";
// Set base path to the currently assembly's folder so that it will find the test assembly
var basePath = Path.GetDirectoryName(testAssembly.CodeBase);
var cmdLineProperties = new Dictionary<string, string>
{
{ "MyGlobalProperty", "true" }
};
var project = new Project(XmlReader.Create(new StringReader(projectXml)), cmdLineProperties, null);
project.FullPath = Path.Combine(project.DirectoryPath, "test.csproj");
// Act
var factory = new ProjectFactory(project) { Build = false };
factory.ProjectProperties.Add("MyGlobalProperty", "false"); // This shouldn't be applied
factory.ProjectProperties.Add("TestProperty", "true"); // This should be applied
var packageBuilder = factory.CreateBuilder(basePath);
// Assert
Assert.True(project.GetProperty("MyGlobalProperty").IsGlobalProperty);
Assert.False(project.GetProperty("TestProperty").IsGlobalProperty);
Assert.Equal("true", project.GetProperty("MyGlobalProperty").UnevaluatedValue, StringComparer.OrdinalIgnoreCase);
Assert.Equal("true", project.GetProperty("TestProperty").UnevaluatedValue, StringComparer.OrdinalIgnoreCase);
}
private PackageDependency CreateDependencyFromProject(Project project)
{
try
{
var projectFactory = new ProjectFactory(project);
projectFactory.Build = Build;
projectFactory.ProjectProperties = ProjectProperties;
projectFactory.BaseTargetPath = BaseTargetPath;
projectFactory.SolutionName = SolutionName;
projectFactory.BuildProject();
var builder = new PackageBuilder();
try
{
AssemblyMetadataExtractor.ExtractMetadata(builder, projectFactory.TargetPath);
}
catch
{
projectFactory.ExtractMetadataFromProject(builder);
}
projectFactory.InitializeProperties(builder);
projectFactory.ProcessNuspec(builder, null);
return new PackageDependency(
builder.Id,
VersionUtility.ParseVersionSpec(builder.Version.ToString()));
}
catch (Exception ex)
{
var message = string.Format(
CultureInfo.InvariantCulture,
LocalizedResourceManager.GetString("Error_ProcessingNuspecFile"),
project.FullPath,
ex.Message);
throw new CommandLineException(message, ex);
}
}
/// <summary>
/// Recursively execute the specified action on the current project and
/// projects referenced by the current project.
/// </summary>
/// <param name="action">The action to be executed.</param>
/// <param name="alreadyAppliedProjects">The collection of projects that have been processed.
/// It is used to avoid processing the same project more than once.</param>
private void RecursivelyApply(Action<ProjectFactory> action, ProjectCollection alreadyAppliedProjects)
{
action(this);
foreach (var item in _project.GetItems(ProjectReferenceItemType))
{
string fullPath = item.GetMetadataValue("FullPath");
if (!string.IsNullOrEmpty(fullPath) &&
!NuspecFileExists(fullPath) &&
alreadyAppliedProjects.GetLoadedProjects(fullPath).IsEmpty())
{
var project = new Project(
fullPath,
globalProperties: null,
toolsVersion: null,
projectCollection: alreadyAppliedProjects);
var referencedProject = new ProjectFactory(project);
referencedProject.Logger = _logger;
referencedProject.IncludeSymbols = IncludeSymbols;
referencedProject.Build = Build;
referencedProject.IncludeReferencedProjects = IncludeReferencedProjects;
referencedProject.ProjectProperties = ProjectProperties;
referencedProject.TargetFramework = TargetFramework;
referencedProject.BaseTargetPath = BaseTargetPath;
referencedProject.SolutionName = SolutionName;
referencedProject.BuildProject();
referencedProject.RecursivelyApply(action, alreadyAppliedProjects);
}
}
}
private void BuildFromProjectFile(string path)
{
var factory = new ProjectFactory(path) {
IsTool = Tool,
Logger = Console
};
// Specify the configuration
factory.Properties.Add("Configuration", Configuration ?? "Release");
// Create a builder for the main package as well as the sources/symbols package
PackageBuilder mainPackageBuilder = factory.CreateBuilder();
// Build the main package
BuildPackage(path, mainPackageBuilder);
// If we're excluding symbols then do nothing else
if (!Symbols) {
return;
}
Console.WriteLine();
Console.WriteLine(NuGetResources.PackageCommandAttemptingToBuildSymbolsPackage, Path.GetFileName(path));
factory.IncludeSymbols = true;
PackageBuilder symbolsBuilder = factory.CreateBuilder();
// Get the file name for the sources package and build it
string outputPath = GetOutputPath(symbolsBuilder, symbols: true);
BuildPackage(path, symbolsBuilder, outputPath);
}
public void ProjectFactoryInitializesPropertiesForPreprocessorFromAssemblyMetadata()
{
// Arrange
var testAssembly = Assembly.GetExecutingAssembly();
const string inputSpec = @"<?xml version=""1.0""?>
<package>
<metadata>
<id>$id$</id>
<version>$version$</version>
<description>$description$</description>
<authors>$owner$</authors>
<copyright>$copyright$</copyright>
<licenseUrl>http://nuget.codeplex.com/license</licenseUrl>
<projectUrl>http://nuget.codeplex.com</projectUrl>
<tags>nuget</tags>
</metadata>
</package>";
var projectXml = @"<?xml version=""1.0"" encoding=""utf-8""?>
<Project ToolsVersion=""4.0"" xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
<PropertyGroup>
<ProjectGuid>{F879F274-EFA0-4157-8404-33A19B4E6AEC}</ProjectGuid>
<OutputType>Library</OutputType>
<RootNamespace>NuGet.Test</RootNamespace>
<AssemblyName>" + testAssembly.GetName().Name + @"</AssemblyName>
<TargetFrameworkProfile Condition="" '$(TargetFrameworkVersion)' == 'v4.0' "">Client</TargetFrameworkProfile>
<OutputPath>.</OutputPath> <!-- Force it to look for the assembly in the base path -->
</PropertyGroup>
<ItemGroup>
<Compile Include=""..\..\Dummy.cs"">
<Link>Dummy.cs</Link>
</Compile>
</ItemGroup>
<Import Project=""$(MSBuildToolsPath)\Microsoft.CSharp.targets"" />
</Project>";
// Set base path to the currently assembly's folder so that it will find the test assembly
var basePath = Path.GetDirectoryName(testAssembly.CodeBase);
var project = new Project(XmlReader.Create(new StringReader(projectXml)));
project.FullPath = Path.Combine(project.DirectoryPath, "test.csproj");
// Act
var factory = new ProjectFactory(project) { Build = false };
var packageBuilder = factory.CreateBuilder(basePath);
var actual = Preprocessor.Process(inputSpec.AsStream(), factory, false);
// assert
var expected = @"<?xml version=""1.0""?>
<package>
<metadata>
<id>" + testAssembly.GetName().Name + @"</id>
<version>" + testAssembly.GetCustomAttribute<AssemblyInformationalVersionAttribute>().InformationalVersion + @"</version>
<description></description>
<authors>Outercurve</authors>
<copyright>" + testAssembly.GetCustomAttribute<AssemblyCopyrightAttribute>().Copyright + @"</copyright>
<licenseUrl>http://nuget.codeplex.com/license</licenseUrl>
<projectUrl>http://nuget.codeplex.com</projectUrl>
<tags>nuget</tags>
</metadata>
</package>";
Assert.Equal(expected, actual);
}
