public void GetTargetFramework_NoTFM_ReturnsTargetFrameworkVersion()
{
// Arrange
const string targetFramework = "v4.6.1";
var projectInstance = new ProjectInstance(ProjectRootElement.Create());
projectInstance.SetProperty(ProjectLoadListener.TargetFrameworkVersion, targetFramework);
// Act
var tfm = ProjectLoadListener.GetTargetFrameworks(projectInstance);
// Assert
Assert.Equal(targetFramework, tfm.First());
}
public void TryGetConfiguration_FailsIfNoLanguageVersion()
{
// Arrange
var projectInstance = new ProjectInstance(ProjectRootElement.Create());
projectInstance.SetProperty("RazorDefaultConfiguration", "Razor-13.37");
// Act
var result = LatestProjectConfigurationProvider.TryGetConfiguration(projectInstance, out var configuration);
// Assert
Assert.False(result);
Assert.Null(configuration);
}
public void GetRootNamespace_ReturnsRootNamespace()
{
// Arrange
var expectedRootNamespace = "SomeApp.Root.Namespace";
var projectInstance = new ProjectInstance(ProjectRootElement.Create());
projectInstance.SetProperty(LatestProjectConfigurationProvider.RootNamespaceProperty, expectedRootNamespace);
// Act
var rootNamespace = LatestProjectConfigurationProvider.GetRootNamespace(projectInstance);
// Assert
Assert.Equal(expectedRootNamespace, rootNamespace);
}
public void TryGetLanguageVersion_SucceedsWithUnknownLanguageVersion_DefaultsToLatest()
{
// Arrange
var projectInstance = new ProjectInstance(ProjectRootElement.Create());
projectInstance.SetProperty("RazorLangVersion", "13.37");
// Act
var result = LatestProjectConfigurationProvider.TryGetLanguageVersion(projectInstance, out var languageVersion);
// Assert
Assert.True(result);
Assert.Same(RazorLanguageVersion.Latest, languageVersion);
}
public void TryGetLanguageVersion_FailsIfEmptyLanguageVersion()
{
// Arrange
var projectInstance = new ProjectInstance(ProjectRootElement.Create());
projectInstance.SetProperty("RazorLangVersion", string.Empty);
// Act
var result = LatestProjectConfigurationProvider.TryGetLanguageVersion(projectInstance, out var languageVersion);
// Assert
Assert.False(result);
Assert.Null(languageVersion);
}
public void TryGetDefaultConfiguration_SucceedsWithValidConfiguration()
{
// Arrange
var expectedConfiguration = "Razor-13.37";
var projectInstance = new ProjectInstance(ProjectRootElement.Create());
projectInstance.SetProperty("RazorDefaultConfiguration", expectedConfiguration);
// Act
var result = LatestProjectConfigurationProvider.TryGetDefaultConfiguration(projectInstance, out var defaultConfiguration);
// Assert
Assert.True(result);
Assert.Equal(expectedConfiguration, defaultConfiguration);
}
public bool BuildProject(ProjectInstance instance, string [] targetNames, IDictionary globalProperties)
{
if (globalProperties != null)
{
foreach (DictionaryEntry de in globalProperties)
{
//Note: trying to set this on the project causes the project to be added to the PC
// again, which of course, fails
instance.SetProperty((string)de.Key, (string)de.Value);
}
}
//FIXME: assumption that we are still using the same PC!
return(instance.Build(targetNames, ProjectCollection.Loggers));
}
private IEnumerable <string> ResolveAssemblyReferences(Project project)
{
// Use MSBuild to figure out the full path of the referenced assemblies
ProjectInstance projectInstance = project.CreateProjectInstance();
projectInstance.SetProperty("BuildingProject", "false");
project.SetProperty("DesignTimeBuild", "true");
projectInstance.Build("ResolveAssemblyReferences", new[] { new ConsoleLogger(LoggerVerbosity.Minimal) });
ICollection <ProjectItemInstance> items = projectInstance.GetItems("_ResolveAssemblyReferenceResolvedFiles");
string baseDirectory = Path.GetDirectoryName(_projectLocation);
// ReSharper disable once AssignNullToNotNullAttribute
return(items.Select(i => Path.Combine(baseDirectory, i.GetMetadataValue("Identity"))));
}
// FIXME: Exception should be caught at caller site.
bool DoBuildTarget(ProjectTargetInstance target, TargetResult targetResult, InternalBuildArguments args)
{
var request = submission.BuildRequest;
// Here we check cancellation (only after TargetStarted event).
if (args.CheckCancel())
{
targetResult.Failure(new BuildAbortedException("Build has canceled"));
return(false);
}
try {
foreach (var child in target.Children)
{
// Evaluate additional target properties
var tp = child as ProjectPropertyGroupTaskInstance;
if (tp != null)
{
if (!args.Project.EvaluateCondition(tp.Condition))
{
continue;
}
foreach (var p in tp.Properties)
{
if (!args.Project.EvaluateCondition(p.Condition))
{
continue;
}
var value = args.Project.ExpandString(p.Value);
project.SetProperty(p.Name, value);
}
continue;
}
var ii = child as ProjectItemGroupTaskInstance;
if (ii != null)
{
if (!args.Project.EvaluateCondition(ii.Condition))
{
continue;
}
foreach (var item in ii.Items)
{
if (!args.Project.EvaluateCondition(item.Condition))
{
continue;
}
project.AddItem(item.ItemType, project.ExpandString(item.Include));
}
continue;
}
var task = child as ProjectTaskInstance;
if (task != null)
{
current_task = task;
if (!args.Project.EvaluateCondition(task.Condition))
{
LogMessageEvent(new BuildMessageEventArgs(string.Format("Task '{0}' was skipped because condition '{1}' wasn't met.", task.Name, task.Condition), null, null, MessageImportance.Low));
continue;
}
if (!RunBuildTask(target, task, targetResult, args))
{
return(false);
}
continue;
}
var onError = child as ProjectOnErrorInstance;
if (onError != null)
{
continue; // evaluated under catch clause.
}
throw new NotSupportedException(string.Format("Unexpected Target element children \"{0}\"", child.GetType()));
}
} catch (Exception ex) {
// fallback task specified by OnError element
foreach (var c in target.Children.OfType <ProjectOnErrorInstance> ())
{
if (!args.Project.EvaluateCondition(c.Condition))
{
continue;
}
foreach (var fallbackTarget in project.ExpandString(c.ExecuteTargets).Split(';'))
{
BuildTargetByName(fallbackTarget, args);
}
}
int line = target.Location != null ? target.Location.Line : 0;
int col = target.Location != null ? target.Location.Column : 0;
LogErrorEvent(new BuildErrorEventArgs(null, null, target.FullPath, line, col, 0, 0, ex.Message, null, null));
targetResult.Failure(ex);
return(false);
}
return(true);
}
/// <summary>
/// Resolves the location of the reference files.
/// </summary>
/// <param name="baseProject">The base project.</param>
/// <param name="referenceReplacements">A different set of references to use instead of those in the project.
/// Used by the GacReferencePanel.</param>
public static IList <ReferenceProjectItem> ResolveAssemblyReferences(
MSBuildBasedProject baseProject,
ReferenceProjectItem[] additionalReferences = null, bool resolveOnlyAdditionalReferences = false,
bool logErrorsToOutputPad = true)
{
ProjectInstance project = baseProject.CreateProjectInstance();
project.SetProperty("BuildingProject", "false");
project.SetProperty("DesignTimeBuild", "true");
List <ProjectItemInstance> references = (
from item in project.Items
where ItemType.ReferenceItemTypes.Contains(new ItemType(item.ItemType))
select item
).ToList();
List <ReferenceProjectItem> referenceProjectItems;
if (resolveOnlyAdditionalReferences)
{
// Remove existing references from project
foreach (ProjectItemInstance reference in references)
{
project.RemoveItem(reference);
}
references.Clear();
referenceProjectItems = new List <ReferenceProjectItem>();
}
else
{
// Remove the "Private" meta data.
// This is necessary to detect the default value for "Private"
foreach (ProjectItemInstance reference in references)
{
reference.RemoveMetadata("Private");
}
referenceProjectItems = baseProject.Items.OfType <ReferenceProjectItem>().ToList();
}
if (additionalReferences != null)
{
referenceProjectItems.AddRange(additionalReferences);
foreach (ReferenceProjectItem item in additionalReferences)
{
references.Add(project.AddItem("Reference", item.Include));
}
}
List <string> targets = new List <string>();
if (baseProject.HasProjectType(ProjectTypeGuids.PortableLibrary))
{
targets.Add("ResolveReferences");
targets.Add("DesignTimeResolveAssemblyReferences");
}
else
{
targets.Add("ResolveAssemblyReferences");
}
BuildRequestData requestData = new BuildRequestData(project, targets.ToArray(), new HostServices());
List <ILogger> loggers = new List <ILogger>();
//loggers.Add(new ConsoleLogger(LoggerVerbosity.Diagnostic));
if (logErrorsToOutputPad)
{
loggers.Add(new SimpleErrorLogger());
}
lock (SolutionProjectCollectionLock) {
BuildParameters parameters = new BuildParameters(baseProject.MSBuildProjectCollection);
parameters.Loggers = loggers;
LoggingService.Debug("Started build for ResolveAssemblyReferences");
BuildResult result = BuildManager.DefaultBuildManager.Build(parameters, requestData);
if (result == null)
{
throw new InvalidOperationException("BuildResult is null");
}
LoggingService.Debug("Build for ResolveAssemblyReferences finished: " + result.OverallResult);
}
IEnumerable <ProjectItemInstance> resolvedAssemblyProjectItems = project.GetItems("_ResolveAssemblyReferenceResolvedFiles");
var query =
from msbuildItem in resolvedAssemblyProjectItems
let originalInclude = msbuildItem.GetMetadataValue("OriginalItemSpec")
join item in referenceProjectItems.Where(p => p.ItemType != ItemType.ProjectReference) on originalInclude equals item.Include into referenceItems
select new {
OriginalInclude = originalInclude,
AssemblyName = new DomAssemblyName(msbuildItem.GetMetadataValue("FusionName")),
FullPath = FileUtility.GetAbsolutePath(baseProject.Directory, msbuildItem.GetMetadataValue("Identity")),
Redist = msbuildItem.GetMetadataValue("Redist"),
CopyLocal = bool.Parse(msbuildItem.GetMetadataValue("CopyLocal")),
ReferenceItems = referenceItems
};
// HACK: mscorlib is reported twice for portable library projects (even if we don't specify it as additionalReference)
query = query.DistinctBy(asm => asm.FullPath);
List <ReferenceProjectItem> resolvedAssemblies = new List <ReferenceProjectItem>();
List <ReferenceProjectItem> handledReferenceItems = new List <ReferenceProjectItem>();
foreach (var assembly in query)
{
LoggingService.Debug("Got information about " + assembly.OriginalInclude + "; fullpath=" + assembly.FullPath);
foreach (var referenceItem in assembly.ReferenceItems)
{
referenceItem.AssemblyName = assembly.AssemblyName;
referenceItem.FileName = assembly.FullPath;
referenceItem.Redist = assembly.Redist;
referenceItem.DefaultCopyLocalValue = assembly.CopyLocal;
handledReferenceItems.Add(referenceItem);
}
ReferenceProjectItem firstItem = assembly.ReferenceItems.FirstOrDefault();
if (firstItem != null)
{
resolvedAssemblies.Add(firstItem);
}
else
{
resolvedAssemblies.Add(new ReferenceProjectItem(baseProject, assembly.OriginalInclude)
{
FileName = assembly.FullPath
});
}
}
// Add any assemblies that weren't resolved yet. This is important - for example, this adds back project references.
foreach (var referenceItem in referenceProjectItems.Except(handledReferenceItems))
{
resolvedAssemblies.Add(referenceItem);
}
return(resolvedAssemblies);
}
/// <summary>
/// Resolves the location of the reference files.
/// </summary>
/// <param name="baseProject">The base project.</param>
/// <param name="referenceReplacements">A different set of references to use instead of those in the project.
/// Used by the GacReferencePanel.</param>
internal static void ResolveAssemblyReferences(MSBuildBasedProject baseProject, ReferenceProjectItem[] referenceReplacements)
{
ProjectInstance project = baseProject.CreateProjectInstance();
project.SetProperty("BuildingProject", "false");
List <ProjectItemInstance> references = (
from item in project.Items
where ItemType.ReferenceItemTypes.Contains(new ItemType(item.ItemType))
select item
).ToList();
ReferenceProjectItem[] referenceProjectItems;
if (referenceReplacements == null)
{
// Remove the "Private" meta data.
// This is necessary to detect the default value for "Private"
foreach (ProjectItemInstance reference in references)
{
reference.RemoveMetadata("Private");
}
referenceProjectItems = baseProject.Items.OfType <ReferenceProjectItem>().ToArray();
}
else
{
foreach (ProjectItemInstance reference in references)
{
project.RemoveItem(reference);
}
foreach (ReferenceProjectItem item in referenceReplacements)
{
project.AddItem("Reference", item.Include);
}
referenceProjectItems = referenceReplacements;
}
string[] targets = { "ResolveAssemblyReferences" };
BuildRequestData requestData = new BuildRequestData(project, targets, new HostServices());
List <ILogger> loggers = new List <ILogger>();
if (referenceReplacements == null)
{
loggers.Add(new SimpleErrorLogger());
}
lock (SolutionProjectCollectionLock) {
BuildParameters parameters = new BuildParameters(baseProject.MSBuildProjectCollection);
parameters.Loggers = loggers;
LoggingService.Debug("Started build for ResolveAssemblyReferences");
BuildResult result = BuildManager.DefaultBuildManager.Build(parameters, requestData);
if (result == null)
{
throw new InvalidOperationException("BuildResult is null");
}
LoggingService.Debug("Build for ResolveAssemblyReferences finished: " + result.OverallResult);
}
var referenceDict = new Dictionary <string, ReferenceProjectItem>();
foreach (ReferenceProjectItem item in referenceProjectItems)
{
// references could be duplicate, so we cannot use referenceDict.Add or reference.ToDictionary
referenceDict[item.Include] = item;
}
foreach (ProjectItemInstance item in project.GetItems("_ResolveAssemblyReferenceResolvedFiles"))
{
string originalInclude = item.GetMetadataValue("OriginalItemSpec");
ReferenceProjectItem reference;
if (referenceDict.TryGetValue(originalInclude, out reference))
{
reference.AssemblyName = new Dom.DomAssemblyName(item.GetMetadataValue("FusionName"));
//string fullPath = item.GetEvaluatedMetadata("FullPath"); is incorrect for relative paths
string fullPath = FileUtility.GetAbsolutePath(baseProject.Directory, item.GetMetadataValue("Identity"));
reference.FileName = fullPath;
reference.Redist = item.GetMetadataValue("Redist");
LoggingService.Debug("Got information about " + originalInclude + "; fullpath=" + fullPath);
reference.DefaultCopyLocalValue = bool.Parse(item.GetMetadataValue("CopyLocal"));
}
else
{
LoggingService.Warn("Unknown item " + originalInclude);
}
}
}
/// <summary>
/// Called before the first project configuration is about to be built.
/// </summary>
/// <returns>
/// If the method succeeds, it returns <see cref="F:Microsoft.VisualStudio.VSConstants.S_OK"/>. If it fails, it returns an error code.
/// </returns>
/// <param name="pfCancelUpdate">[in, out] Pointer to a flag indicating cancel update.</param>
int IVsUpdateSolutionEvents.UpdateSolution_StartUpdate(ref int pfCancelUpdate)
{
// This method is called when the entire solution starts to build.
this.WriteLine(LoggerVerbosity.Detailed, "CommonSolutionTargets: UpdateSolution_StartUpdate");
string solutionFilePath = this.dte2.Solution.FullName;
string solutionFolder = Path.GetDirectoryName(solutionFilePath);
string solutionFileName = Path.GetFileName(solutionFilePath);
string targetsFileName = "after." + solutionFileName + ".targets";
if (solutionFolder == null)
{
return(VSConstants.E_UNEXPECTED);
}
string targetsFilePath = Path.Combine(solutionFolder, targetsFileName);
if (!File.Exists(targetsFilePath))
{
return(VSConstants.S_OK);
}
string solutionConfigurationName = this.dte2.Solution.SolutionBuild.ActiveConfiguration.Name;
this.WriteLine(LoggerVerbosity.Detailed, "CommonSolutionTargets: active solution configuration name is \"{0}\"", solutionConfigurationName);
List <ILogger> loggers = new List <ILogger> {
this.MakeBuildLogger()
};
ProjectInstance solutionInitProjectInstance;
try
{
solutionInitProjectInstance = new ProjectInstance(targetsFilePath);
}
catch (Exception ex)
{
this.WriteLine(LoggerVerbosity.Detailed, "CommonSolutionTargets: failed to load targets file \"{0}\", Exception: {1}", targetsFilePath, ex);
return(VSConstants.E_FAIL);
}
solutionInitProjectInstance.SetProperty("Configuration", solutionConfigurationName);
solutionInitProjectInstance.SetProperty("BuildingInsideVisualStudio", "true");
int numberOfPropertiesBeforeBuild = solutionInitProjectInstance.Properties.Count;
var target = GetActiveBuildTarget(nameof(IVsUpdateSolutionEvents.UpdateSolution_StartUpdate));
this.WriteLine(LoggerVerbosity.Detailed, "CommonSolutionTargets: building targets file \"{0}\", target \"{1}\"", targetsFilePath, string.Join(",", target));
solutionInitProjectInstance.Build(target, loggers);
// If solution targets build produced new custom properties, fetch those and add them to the global properties collection.
// Most typical usage for this feature is setting "CustomAfterMicrosoftCommontargets" property.
for (int propertyNumber = numberOfPropertiesBeforeBuild;
propertyNumber < solutionInitProjectInstance.Properties.Count;
propertyNumber++)
{
ProjectPropertyInstance property = solutionInitProjectInstance.Properties.ElementAt(propertyNumber);
if (property.Name.StartsWith("Custom"))
{
this.WriteLine(LoggerVerbosity.Detailed, "CommonSolutionTargets: defined global build property {0} = {1}", property.Name, property.EvaluatedValue);
ProjectCollection.GlobalProjectCollection.SetGlobalProperty(property.Name, property.EvaluatedValue);
}
}
return(VSConstants.S_OK);
}
public void TestSetFibBaseImage(string registry, string repository, string tag, string digest, string expectedFibBaseImage)
{
_projectInstance.SetProperty("FibBaseRegistry", registry);
_projectInstance.SetProperty("FibBaseRepository", repository);
_projectInstance.SetProperty("FibBaseTag", tag);
_projectInstance.SetProperty("FibBaseDigest", digest);
Assert.IsTrue(_projectInstance.Build("SetFibBaseImage", Loggers));
Assert.AreEqual(expectedFibBaseImage, _projectInstance.GetPropertyValue("FibBaseImage"));
}
