public void If_a_project_dependency_is_present_DesignTimeAutoUnify_and_AutoUnify_are_present()
{
var solutionDirectory =
TestAssetsManager.CreateTestInstance("TestAppWithLibrary", callingMethod: "p").Path;
var appDirectory = Path.Combine(solutionDirectory, "TestApp");
var libDirectory = Path.Combine(solutionDirectory, "TestLibrary");
var projectContext = ProjectContext.Create(appDirectory, FrameworkConstants.CommonFrameworks.NetCoreApp10);
var mockProj = ProjectRootElement.Create();
var testSettings = new MigrationSettings(appDirectory, appDirectory, "1.0.0", mockProj);
var testInputs = new MigrationRuleInputs(new[] { projectContext }, mockProj, mockProj.AddItemGroup(),
mockProj.AddPropertyGroup());
new MigrateProjectDependenciesRule().Apply(testSettings, testInputs);
var autoUnify = mockProj.Properties.Where(p => p.Name == "AutoUnify");
autoUnify.Count().Should().Be(1);
autoUnify.First().Value.Should().Be("true");
var designTimeAutoUnify = mockProj.Properties.Where(p => p.Name == "DesignTimeAutoUnify");
designTimeAutoUnify.Count().Should().Be(1);
designTimeAutoUnify.First().Value.Should().Be("true");
}
public void RuntimeOptions_are_copied_from_projectJson_to_runtimeconfig_template_json_file()
{
var testInstance = TestAssetsManager.CreateTestInstance("TestAppWithRuntimeOptions").WithLockFiles();
var projectDir = testInstance.Path;
var projectPath = Path.Combine(testInstance.Path, "project.json");
var project = JObject.Parse(File.ReadAllText(projectPath));
var rawRuntimeOptions = (JObject)project.GetValue("runtimeOptions");
var projectContext = ProjectContext.Create(projectDir, FrameworkConstants.CommonFrameworks.NetCoreApp10);
var testSettings = new MigrationSettings(projectDir, projectDir, "1.0.0", default(ProjectRootElement));
var testInputs = new MigrationRuleInputs(new[] { projectContext }, null, null, null);
new MigrateRuntimeOptionsRule().Apply(testSettings, testInputs);
var migratedRuntimeOptionsPath = Path.Combine(projectDir, s_runtimeConfigFileName);
File.Exists(migratedRuntimeOptionsPath).Should().BeTrue();
Console.WriteLine(migratedRuntimeOptionsPath);
var migratedRuntimeOptionsContent = JObject.Parse(File.ReadAllText(migratedRuntimeOptionsPath));
JToken.DeepEquals(rawRuntimeOptions, migratedRuntimeOptionsContent).Should().BeTrue();
}
private ProjectContext GetProjectContextFromDirectory(string directory, NuGetFramework framework)
{
if (directory == null || framework == null)
{
return(null);
}
var projectRootPath = directory;
if (!File.Exists(Path.Combine(projectRootPath, Project.FileName)))
{
return(null);
}
var projectContext = ProjectContext.Create(
projectRootPath,
framework,
RuntimeEnvironmentRidExtensions.GetAllCandidateRuntimeIdentifiers());
if (projectContext.RuntimeIdentifier == null)
{
return(null);
}
return(projectContext);
}
public void TFMSpecificProjectDependenciesAreMigratedToProjectReferenceUnderConditionItemGroup()
{
var solutionDirectory = TestAssets.Get("TestAppWithLibraryUnderTFM")
.CreateInstance(callingMethod: "p")
.WithSourceFiles()
.Root.FullName;
var appDirectory = Path.Combine(solutionDirectory, "TestApp");
var projectContext = ProjectContext.Create(appDirectory, FrameworkConstants.CommonFrameworks.NetCoreApp11);
var mockProj = ProjectRootElement.Create();
var testSettings = MigrationSettings.CreateMigrationSettingsTestHook(appDirectory, appDirectory, mockProj, null);
var testInputs = new MigrationRuleInputs(new[] { projectContext }, mockProj, mockProj.AddItemGroup(),
mockProj.AddPropertyGroup());
new MigrateProjectDependenciesRule().Apply(testSettings, testInputs);
var projectReferences = mockProj.Items.Where(item => item.ItemType.Equals("ProjectReference", StringComparison.Ordinal));
projectReferences.Count().Should().Be(1);
var projectReference = projectReferences.First();
projectReference.Include.Should().Be(Path.Combine("..", "TestLibrary", "TestLibrary.csproj"));
projectReference.Parent.Condition.Should().Be(" '$(TargetFramework)' == 'netcoreapp1.1' ");
}
private static void CreateDepsInPackageCache(LibraryRange toolLibrary, string projectPath)
{
var context = ProjectContext.Create(projectPath,
FrameworkConstants.CommonFrameworks.DnxCore50, new[] { DefaultRid });
var toolDescription = context.LibraryManager.GetLibraries()
.Select(l => l as PackageDescription)
.Where(l => l != null)
.FirstOrDefault(l => l.Identity.Name == toolLibrary.Name);
var depsPath = Path.Combine(
toolDescription.Path,
Path.GetDirectoryName(toolDescription.Target.RuntimeAssemblies.First().Path),
toolDescription.Identity.Name + FileNameSuffixes.Deps);
var calculator = context.GetOutputPathCalculator(context.ProjectDirectory);
var executable = new Executable(context, calculator);
executable.MakeCompilationOutputRunnable(Constants.DefaultConfiguration);
if (File.Exists(depsPath))
{
File.Delete(depsPath);
}
File.Move(Path.Combine(calculator.GetOutputDirectoryPath(Constants.DefaultConfiguration), "bin" + FileNameSuffixes.Deps), depsPath);
}
public void It_sets_depsfile_in_build_base_path_in_commandspec()
{
var projectDependenciesCommandResolver = SetupProjectDependenciesCommandResolver();
var buildBasePath = Path.Combine(AppContext.BaseDirectory, "basedir");
var commandResolverArguments = new CommandResolverArguments
{
CommandName = "dotnet-hello",
CommandArguments = null,
ProjectDirectory = s_liveProjectDirectory,
Configuration = "Debug",
Framework = FrameworkConstants.CommonFrameworks.NetCoreApp10,
BuildBasePath = buildBasePath
};
var buildCommand = new BuildCommand(
Path.Combine(s_liveProjectDirectory, "project.json"),
buildBasePath: buildBasePath,
framework: FrameworkConstants.CommonFrameworks.NetCoreApp10.ToString())
.Execute().Should().Pass();
var projectContext = ProjectContext.Create(
s_liveProjectDirectory,
FrameworkConstants.CommonFrameworks.NetCoreApp10,
RuntimeEnvironmentRidExtensions.GetAllCandidateRuntimeIdentifiers());
var depsFilePath =
projectContext.GetOutputPaths("Debug", buildBasePath).RuntimeFiles.DepsJson;
var result = projectDependenciesCommandResolver.Resolve(commandResolverArguments);
result.Should().NotBeNull();
result.Args.Should().Contain($"--depsfile {depsFilePath}");
}
/// <summary>
/// Rewrites the specified solution.
/// </summary>
/// <param name="originalSolution">The solution.</param>
/// <param name="rewriter">The rewriter.</param>
/// <returns></returns>
public Result <Solution> Rewrite(Solution originalSolution, IRewriter rewriter)
=> Modify(
original: originalSolution,
getIntermediateValues: solution => solution.ProjectIds,
getEntry: (solution, projectId) => solution.GetProject(projectId),
modifyEntry: project =>
{
var projectContext = ProjectContext.Create(project);
if (projectContext.IsFailure)
{
return(Result.Fail <Project>(projectContext.Error));
}
else
{
var rewriteResult = Rewrite(projectContext.Value, rewriter);
if (rewriteResult.IsFailure)
{
return(Result.Fail <Project>(rewriteResult.Error));
}
else
{
return(Result.Ok(rewriteResult.Value.Project));
}
}
},
getReturnValue: project => project.Solution);
// check the entire project tree that needs to be compiled, duplicated for each framework
private List <ProjectContext> GetProjectsToCheck()
{
if (_args.ShouldSkipDependencies)
{
return(new List <ProjectContext>(1)
{
_rootProject
});
}
// include initial root project
var contextsToCheck = new List <ProjectContext>(1 + _rootProjectDependencies.ProjectDependenciesWithSources.Count)
{
_rootProject
};
// convert ProjectDescription to ProjectContext
var dependencyContexts = _rootProjectDependencies.ProjectDependenciesWithSources.Select
(keyValuePair => ProjectContext.Create(keyValuePair.Value.Path, keyValuePair.Value.Framework));
contextsToCheck.AddRange(dependencyContexts);
return(contextsToCheck);
}
private static ProjectContext GetTemplatesProject(string path)
{
EnsureProjectFile(path);
var templatesProject = ProjectContext.Create(path, NuGetFramework.Parse("netstandardapp1.5"));
return(templatesProject);
}
private void MakeRunnableIfNecessary()
{
var compilationOptions = CompilerUtil.ResolveCompilationOptions(_rootProject, _args.ConfigValue);
// TODO: Make this opt in via another mechanism
var makeRunnable = compilationOptions.EmitEntryPoint.GetValueOrDefault() ||
_rootProject.IsTestProject();
if (makeRunnable)
{
var outputPathCalculator = _rootProject.GetOutputPathCalculator(_args.OutputValue);
var rids = new List <string>();
if (string.IsNullOrEmpty(_args.RuntimeValue))
{
rids.AddRange(PlatformServices.Default.Runtime.GetAllCandidateRuntimeIdentifiers());
}
else
{
rids.Add(_args.RuntimeValue);
}
var runtimeContext = ProjectContext.Create(_rootProject.ProjectDirectory, _rootProject.TargetFramework, rids);
var executable = new Executable(runtimeContext, outputPathCalculator);
executable.MakeCompilationOutputRunnable(_args.ConfigValue);
}
}
private bool CompileDependencies(bool incremental)
{
if (_args.ShouldSkipDependencies)
{
return(true);
}
foreach (var dependency in Sort(_rootProjectDependencies.ProjectDependenciesWithSources))
{
var dependencyProjectContext = ProjectContext.Create(dependency.Path, dependency.Framework, new[] { _rootProject.RuntimeIdentifier });
try
{
if (incremental && !NeedsRebuilding(dependencyProjectContext, new ProjectDependenciesFacade(dependencyProjectContext, _args.ConfigValue)))
{
continue;
}
if (!InvokeCompileOnDependency(dependency))
{
return(false);
}
}
finally
{
StampProjectWithSDKVersion(dependencyProjectContext);
}
}
return(true);
}
public OperationExecutor(
[NotNull] CommonOptions options,
[CanBeNull] string environment)
{
var projectFile = Path.Combine(Directory.GetCurrentDirectory(), Project.FileName);
var project = ProjectReader.GetProject(projectFile);
var projectConfiguration = options.Configuration ?? Constants.DefaultConfiguration;
var projectFramework = options.Framework;
var projectContext = ProjectContext.Create(project.ProjectFilePath,
projectFramework,
RuntimeEnvironmentRidExtensions.GetAllCandidateRuntimeIdentifiers());
var runtimeOutputPath = projectContext.GetOutputPaths(projectConfiguration)?.RuntimeOutputPath;
if (!string.IsNullOrEmpty(runtimeOutputPath))
{
Reporter.Verbose.WriteLine(
ToolsCliStrings.LogDataDirectory(runtimeOutputPath));
Environment.SetEnvironmentVariable(DataDirEnvName, runtimeOutputPath);
#if NET451
AppDomain.CurrentDomain.SetData("DataDirectory", runtimeOutputPath);
#endif
}
var assemblyName = project.GetCompilerOptions(projectFramework, projectConfiguration).OutputName;
var projectDir = project.ProjectDirectory;
var rootNamespace = project.Name;
var assemblyLoader = new AssemblyLoader(Assembly.Load);
var projectAssembly = assemblyLoader.Load(assemblyName);
_contextOperations = new LazyRef <DbContextOperations>(
() => new DbContextOperations(
new LoggerProvider(name => new ConsoleCommandLogger(name)),
projectAssembly,
projectAssembly,
environment,
projectDir));
_databaseOperations = new LazyRef <DatabaseOperations>(
() => new DatabaseOperations(
new LoggerProvider(name => new ConsoleCommandLogger(name)),
assemblyLoader,
projectAssembly,
environment,
projectDir,
projectDir,
rootNamespace));
_migrationsOperations = new LazyRef <MigrationsOperations>(
() => new MigrationsOperations(
new LoggerProvider(name => new ConsoleCommandLogger(name)),
projectAssembly,
assemblyLoader,
projectAssembly,
environment,
projectDir,
projectDir,
rootNamespace));
}
public void RuntimeOptionsAreCopiedFromProjectJsonToRuntimeConfigTemplateJsonFile()
{
var testInstance = TestAssets.Get("TestAppWithRuntimeOptions")
.CreateInstance()
.WithSourceFiles()
.Root;
var projectDir = testInstance.FullName;
var projectPath = Path.Combine(projectDir, "project.json");
var project = JObject.Parse(File.ReadAllText(projectPath));
var rawRuntimeOptions = (JObject)project.GetValue("runtimeOptions");
var projectContext = ProjectContext.Create(projectDir, FrameworkConstants.CommonFrameworks.NetCoreApp10);
var testSettings = MigrationSettings.CreateMigrationSettingsTestHook(projectDir, projectDir, default(ProjectRootElement));
var testInputs = new MigrationRuleInputs(new[] { projectContext }, null, null, null);
new MigrateRuntimeOptionsRule().Apply(testSettings, testInputs);
var migratedRuntimeOptionsPath = Path.Combine(projectDir, s_runtimeConfigFileName);
File.Exists(migratedRuntimeOptionsPath).Should().BeTrue();
var migratedRuntimeOptionsContent = JObject.Parse(File.ReadAllText(migratedRuntimeOptionsPath));
JToken.DeepEquals(rawRuntimeOptions, migratedRuntimeOptionsContent).Should().BeTrue();
}
/// <summary>
/// Builds the package library.
/// </summary>
/// <returns></returns>
public Result <ILibrary> Build(ProjectContext projectContext)
=>
//cleanup
MakeTypesPartial(projectContext)
.OnSuccess(RemoveRegionDirectives)
.OnSuccess(RemoveUnusedUsingDirectives)
//pull out extension methods which depend on interweaves
.OnSuccess(CreateWalker)
.OnSuccess(ExtractInterwovenExtensionMethods)
//pull out members which depend on interweaves
.OnSuccess(CreateWalker)
.OnSuccess(ExtractInterwovenTypeMembers)
//pull out remaining types
.OnSuccess(CreateWalker)
.OnSuccess(ExtractMemberContainers)
//cleanup
.OnSuccess(p => ProjectContext.Create(p))
.OnSuccess(RemoveUnusedUsingDirectives)
//allow verification if needed
.OnSuccess(pc => pc.Project)
.OnSuccess(AfterRewrites)
.OnSuccess(() => Result.Ok(_library));
/// <summary>
/// Rewrites the specified document context.
/// </summary>
/// <param name="document">The original document.</param>
/// <param name="rewriter">The rewriter.</param>
/// <returns></returns>
public Result <DocumentContext> Rewrite(DocumentContext document, IRewriter rewriter)
{
//only rewrite .vb and .cs
if (document.Document.SourceCodeKind != SourceCodeKind.Regular ||
document.Document.Name.ToLowerInvariant().EndsWith(".assemblyattributes.cs") ||
document.Document.Name.ToLowerInvariant().EndsWith(".assemblyinfo.cs"))
{
return(Result.Ok(document));
}
var newDocResult = rewriter.Rewrite(document, _log);
if (newDocResult.IsFailure)
{
return(Result.Fail <DocumentContext>(newDocResult.Error));
}
var newDoc = newDocResult.Value;
var newProject = newDoc.Project;
var newProjectContext = ProjectContext.Create(newProject);
if (newProjectContext.IsFailure)
{
return(Result.Fail <DocumentContext>(newProjectContext.Error));
}
else
{
var newDocContext =
newProjectContext.Value
.Documents
.Where(x => x.Document.Id == document.Document.Id)
.Single();
return(Result.Ok(newDocContext));
}
}
private static IEnumerable <ProjectContext> GenerateProjectContextsFromString(
string projectDirectory,
string json)
{
var globalJson = Path.Combine(new DirectoryInfo(projectDirectory).Parent.FullName, "global.json");
if (!File.Exists(globalJson))
{
var file = new FileInfo(globalJson);
try
{
File.WriteAllText(file.FullName, @"{}");
}
catch (IOException)
{
//this means there is someone else writing to the file already. So, just ignore it.
}
}
var testPj = new ProjectJsonBuilder(null)
.FromStringBase(json)
.SaveToDisk(projectDirectory);
var projectContexts = ProjectContext.CreateContextForEachFramework(projectDirectory);
if (projectContexts.Count() == 0)
{
projectContexts = new []
{
ProjectContext.Create(testPj, FrameworkConstants.CommonFrameworks.NetCoreApp10)
};
}
return(projectContexts);
}
public void It_resolves_tools_whose_package_name_is_different_than_dll_name()
{
var configuration = "Debug";
var testAssetManager = new TestAssetsManager(Path.Combine(RepoRoot, "TestAssets", "TestProjects"));
var testInstance = testAssetManager.CreateTestInstance("AppWithDirectDependencyWithOutputName")
.WithLockFiles();
var buildCommand = new BuildCommand(
Path.Combine(testInstance.TestRoot, "project.json"),
configuration: configuration)
.ExecuteWithCapturedOutput()
.Should()
.Pass();
var context = ProjectContext.Create(testInstance.TestRoot, FrameworkConstants.CommonFrameworks.NetCoreApp10);
var factory = new ProjectDependenciesCommandFactory(
FrameworkConstants.CommonFrameworks.NetCoreApp10,
configuration,
null,
null,
testInstance.TestRoot);
var command = factory.Create("dotnet-tool-with-output-name", null);
command.CommandArgs.Should().Contain(
Path.Combine("ToolWithOutputName", "1.0.0", "lib", "netcoreapp1.0", "dotnet-tool-with-output-name.dll"));
}
private ProjectContext GetProjectContextFromDirectory(string directory, NuGetFramework framework)
{
if (directory == null || framework == null)
{
return(null);
}
var projectRootPath = directory;
if (!File.Exists(Path.Combine(projectRootPath, Project.FileName)))
{
return(null);
}
var projectContext = ProjectContext.Create(
projectRootPath,
framework,
PlatformServices.Default.Runtime.GetAllCandidateRuntimeIdentifiers());
if (projectContext.RuntimeIdentifier == null)
{
return(null);
}
return(projectContext);
}
public void It_resolves_desktop_apps_when_configuration_is_Release()
{
var configuration = "Release";
var testAssetManager = new TestAssetsManager(Path.Combine(RepoRoot, "TestAssets", "DesktopTestProjects"));
var testInstance = testAssetManager.CreateTestInstance("AppWithDirectDependencyDesktopAndPortable")
.WithLockFiles();
var buildCommand = new BuildCommand(
Path.Combine(testInstance.TestRoot, "project.json"),
configuration: configuration)
.ExecuteWithCapturedOutput()
.Should()
.Pass();
var context = ProjectContext.Create(testInstance.TestRoot, s_desktopTestFramework);
var factory = new ProjectDependenciesCommandFactory(
s_desktopTestFramework,
configuration,
null,
null,
testInstance.TestRoot);
var command = factory.Create("dotnet-desktop-and-portable", null);
command.CommandName.Should().Contain(Path.Combine(testInstance.TestRoot, "bin", configuration));
Path.GetFileName(command.CommandName).Should().Be("dotnet-desktop-and-portable.exe");
}
public void It_sets_depsfile_based_on_build_base_path_when_returning_a_commandspec()
{
var projectDependenciesCommandResolver = SetupProjectDependenciesCommandResolver();
var commandResolverArguments = new CommandResolverArguments
{
CommandName = "dotnet-hello",
CommandArguments = null,
ProjectDirectory = s_liveProjectDirectory,
Configuration = "Debug",
Framework = FrameworkConstants.CommonFrameworks.NetStandardApp15,
BuildBasePath = AppContext.BaseDirectory
};
var projectContext = ProjectContext.Create(
s_liveProjectDirectory,
FrameworkConstants.CommonFrameworks.NetStandardApp15,
PlatformServices.Default.Runtime.GetAllCandidateRuntimeIdentifiers());
var depsFilePath =
projectContext.GetOutputPaths("Debug", AppContext.BaseDirectory).RuntimeFiles.DepsJson;
var result = projectDependenciesCommandResolver.Resolve(commandResolverArguments);
result.Should().NotBeNull();
result.Args.Should().Contain($"--depsfile {depsFilePath}");
}
private ProjectRootElement MigrateProject(
string solution,
string project,
NuGetFramework targetFramework)
{
var solutionDirectory = TestAssets.Get(solution)
.CreateInstance(callingMethod: "p")
.WithSourceFiles()
.Root.FullName;
var appDirectory = Path.Combine(solutionDirectory, project);
var projectContext = ProjectContext.Create(appDirectory, targetFramework);
var mockProj = ProjectRootElement.Create();
var testSettings = MigrationSettings.CreateMigrationSettingsTestHook(appDirectory, appDirectory, mockProj, null);
var testInputs = new MigrationRuleInputs(new[] { projectContext }, mockProj, mockProj.AddItemGroup(),
mockProj.AddPropertyGroup());
new MigrateProjectDependenciesRule().Apply(testSettings, testInputs);
var s = mockProj.Items.Select(p => $"ItemType = {p.ItemType}, Include = {p.Include}");
Console.WriteLine(string.Join(Environment.NewLine, s));
return(mockProj);
}
private ProjectContext GetProjectContextFromDirectory(string directory, NuGetFramework framework)
{
if (directory == null || framework == null)
{
return(null);
}
var projectRootPath = directory;
if (!File.Exists(Path.Combine(projectRootPath, Project.FileName)))
{
return(null);
}
var projectContext = ProjectContext.Create(
projectRootPath,
framework,
DotnetRuntimeIdentifiers.InferCurrentRuntimeIdentifiers());
if (projectContext.RuntimeIdentifier == null)
{
return(null);
}
return(projectContext);
}
public void Generate_deps_json_method_doesnt_overwrite_when_deps_file_already_exists()
{
var context = ProjectContext.Create(Path.Combine(s_liveProjectDirectory, "project.json"), s_toolPackageFramework);
var nugetPackagesRoot = context.PackagesDirectory;
var toolPathCalculator = new ToolPathCalculator(nugetPackagesRoot);
var lockFilePath = toolPathCalculator.GetLockFilePath(
"dotnet-portable",
new NuGetVersion("1.0.0"),
s_toolPackageFramework);
var lockFile = LockFileReader.Read(lockFilePath, designTime: false);
var depsJsonFile = Path.Combine(
Path.GetDirectoryName(lockFilePath),
"dotnet-portable.deps.json");
if (File.Exists(depsJsonFile))
{
File.Delete(depsJsonFile);
}
File.WriteAllText(depsJsonFile, "temp");
var projectToolsCommandResolver = SetupProjectToolsCommandResolver();
projectToolsCommandResolver.GenerateDepsJsonFile(lockFile, depsJsonFile);
File.ReadAllText(depsJsonFile).Should().Be("temp");
File.Delete(depsJsonFile);
}
public static void Main(string[] args)
{
// These are packages that are not part of .NET Core and must be excluded
string[] excludedPackages =
{
"Microsoft.Management.Infrastructure",
"Microsoft.Management.Infrastructure.Native",
"Microsoft.mshtml"
};
// The TypeCatalogGen project takes this as input
var outputPath = "../TypeCatalogGen/powershell.inc";
// Get a context for our top level project
var context = ProjectContext.Create("../Microsoft.PowerShell.SDK", NuGetFramework.Parse("netstandard1.6"));
System.IO.File.WriteAllLines(outputPath,
// Get the target for the current runtime
from t in context.LockFile.Targets where t.RuntimeIdentifier == context.RuntimeIdentifier
// Get the packages (not projects)
from x in t.Libraries where (x.Type == "package" && !excludedPackages.Contains(x.Name))
// Get the real reference assemblies
from y in x.CompileTimeAssemblies where y.Path.EndsWith(".dll")
// Construct the path to the assemblies
select $"{context.PackagesDirectory}/{x.Name}/{x.Version}/{y.Path};");
Console.WriteLine($"List of reference assemblies written to {outputPath}");
}
public void Migrating_Single_TFM_project_Populates_TargetFrameworks_with_short_tfm()
{
var testDirectory = Temp.CreateDirectory().Path;
var testPJ = new ProjectJsonBuilder(TestAssetsManager)
.FromTestAssetBase("TestAppWithRuntimeOptions")
.WithCustomProperty("buildOptions", new Dictionary <string, string>
{
{ "emitEntryPoint", "false" }
})
.SaveToDisk(testDirectory);
var projectContext = ProjectContext.Create(testDirectory, FrameworkConstants.CommonFrameworks.NetCoreApp10);
var mockProj = ProjectRootElement.Create();
// Run BuildOptionsRule
var migrationSettings = new MigrationSettings(testDirectory, testDirectory, "1.0.0", mockProj);
var migrationInputs = new MigrationRuleInputs(
new[] { projectContext },
mockProj,
mockProj.AddItemGroup(),
mockProj.AddPropertyGroup());
new MigrateTFMRule().Apply(migrationSettings, migrationInputs);
mockProj.Properties.Count(p => p.Name == "TargetFrameworks").Should().Be(1);
mockProj.Properties.First(p => p.Name == "TargetFrameworks").Value.Should().Be("netcoreapp1.0");
}
public void SpecifiedDefaultPropertiesAreRemovedWhenTheyExistInTheCsprojTemplate()
{
// Setup project with default properties
var defaultPropertiesExpectedToBeRemoved = new string[]
{
"OutputType",
"TargetExt"
};
var defaultValue = "defaultValue";
var templateProj = ProjectRootElement.Create();
var defaultPropertyGroup = templateProj.AddPropertyGroup();
foreach (var defaultPropertyName in defaultPropertiesExpectedToBeRemoved)
{
defaultPropertyGroup.AddProperty(defaultPropertyName, defaultValue);
}
// Setup projectcontext
var testProjectDirectory = TestAssetsManager.CreateTestInstance("TestAppWithRuntimeOptions").Path;
var projectContext = ProjectContext.Create(testProjectDirectory, FrameworkConstants.CommonFrameworks.NetCoreApp10);
var testSettings = MigrationSettings.CreateMigrationSettingsTestHook(testProjectDirectory, testProjectDirectory, templateProj);
var testInputs = new MigrationRuleInputs(new[] { projectContext }, templateProj, templateProj.AddItemGroup(),
templateProj.AddPropertyGroup());
new MigrateBuildOptionsRule().Apply(testSettings, testInputs);
defaultPropertyGroup.Properties.Count.Should().Be(0);
}
public void Migrating_netcoreapp_project_Does_not_populate_TargetFrameworkIdentifier_and_TargetFrameworkVersion()
{
var testDirectory = Temp.CreateDirectory().Path;
var testPJ = new ProjectJsonBuilder(TestAssetsManager)
.FromTestAssetBase("TestAppWithRuntimeOptions")
.WithCustomProperty("buildOptions", new Dictionary <string, string>
{
{ "emitEntryPoint", "false" }
})
.SaveToDisk(testDirectory);
var projectContext = ProjectContext.Create(testDirectory, FrameworkConstants.CommonFrameworks.NetCoreApp10);
var mockProj = ProjectRootElement.Create();
var migrationSettings = new MigrationSettings(testDirectory, testDirectory, mockProj);
var migrationInputs = new MigrationRuleInputs(
new[] { projectContext },
mockProj,
mockProj.AddItemGroup(),
mockProj.AddPropertyGroup());
new MigrateTFMRule().Apply(migrationSettings, migrationInputs);
mockProj.Properties.Count(p => p.Name == "TargetFrameworkIdentifier").Should().Be(0);
mockProj.Properties.Count(p => p.Name == "TargetFrameworkVersion").Should().Be(0);
}
private static ProjectContext GenerateProjectContextFromString(string projectDirectory, string json)
{
var testPj = new ProjectJsonBuilder(null)
.FromStringBase(json)
.SaveToDisk(projectDirectory);
return(ProjectContext.Create(testPj, FrameworkConstants.CommonFrameworks.NetCoreApp10));
}
private ScriptVariablesFixture(string rid)
{
var projectJson = Path.Combine(TestAssetPath, "project.json");
var command = new Mock <ICommand>();
command.Setup(c => c.Execute()).Returns(new CommandResult());
command.Setup(c => c.OnErrorLine(It.IsAny <Action <string> >())).Returns(() => command.Object);
command.Setup(c => c.OnOutputLine(It.IsAny <Action <string> >())).Returns(() => command.Object);
var commandFactory = new Mock <ICommandFactory>();
commandFactory.Setup(c => c
.Create(
It.IsAny <string>(),
It.IsAny <IEnumerable <string> >(),
It.IsAny <NuGetFramework>(),
It.IsAny <string>()))
.Returns(command.Object);
var _args = new CompilerCommandApp("dotnet compile", ".NET Compiler", "Compiler for the .NET Platform");
_args.ConfigValue = ConfigValue;
PreCompileScriptVariables = new Dictionary <string, string>();
PostCompileScriptVariables = new Dictionary <string, string>();
var _scriptRunner = new Mock <IScriptRunner>();
_scriptRunner.Setup(
s =>
s.RunScripts(It.IsAny <ProjectContext>(), It.IsAny <string>(), It.IsAny <Dictionary <string, string> >()))
.Callback <ProjectContext, string, Dictionary <string, string> >((p, n, v) =>
{
if (n.Equals(ScriptNames.PreCompile))
{
PreCompileScriptVariables = v;
}
if (n.Equals(ScriptNames.PostCompile))
{
PostCompileScriptVariables = v;
}
});
var managedCompiler = new ManagedCompiler(_scriptRunner.Object, commandFactory.Object);
var rids = new List <string>();
if (!string.IsNullOrEmpty(rid))
{
rids.Add(rid);
}
var context = ProjectContext.Create(projectJson, new NuGetFramework("dnxcore", new Version(5, 0)), rids);
managedCompiler.Compile(context, _args);
RuntimeOutputDir = Path.Combine(OutputPath, rid);
}
private ProjectId AddProject(ProjectContext project)
{
// Create the framework specific project and add it to the workspace
var projectInfo = ProjectInfo.Create(
ProjectId.CreateNewId(),
VersionStamp.Create(),
project.ProjectFile.Name + "+" + project.TargetFramework,
project.ProjectFile.Name,
LanguageNames.CSharp,
project.ProjectFile.ProjectFilePath);
OnProjectAdded(projectInfo);
// TODO: ctor argument?
var configuration = "Debug";
var compilationOptions = project.ProjectFile.GetCompilerOptions(project.TargetFramework, configuration);
var compilationSettings = ToCompilationSettings(compilationOptions, project.TargetFramework, project.ProjectFile.ProjectDirectory);
OnParseOptionsChanged(projectInfo.Id, new CSharpParseOptions(compilationSettings.LanguageVersion, preprocessorSymbols: compilationSettings.Defines));
OnCompilationOptionsChanged(projectInfo.Id, compilationSettings.CompilationOptions);
foreach (var file in project.ProjectFile.Files.SourceFiles)
{
AddSourceFile(projectInfo, file);
}
var exporter = project.CreateExporter(configuration);
foreach (var dependency in exporter.GetDependencies())
{
var projectDependency = dependency.Library as ProjectDescription;
if (projectDependency != null)
{
var projectDependencyContext = ProjectContext.Create(projectDependency.Project.ProjectFilePath, projectDependency.Framework);
var id = AddProject(projectDependencyContext);
OnProjectReferenceAdded(projectInfo.Id, new ProjectReference(id));
}
else
{
foreach (var asset in dependency.CompilationAssemblies)
{
OnMetadataReferenceAdded(projectInfo.Id, GetMetadataReference(asset.ResolvedPath));
}
}
foreach (var file in dependency.SourceReferences)
{
AddSourceFile(projectInfo, file);
}
}
return(projectInfo.Id);
}
