mirrors/dotnet-installer
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
dotnet-installer/test/dotnet-compile.UnitTests/GivenThatICareAboutScriptVariablesFromAManagedCompiler.cs

235 lines
9.8 KiB
C#
Raw Normal View History

Refactoring dotnet-compile to make adding the script variable testable. So far, moved it to have a compiler controller and two separate compilers: native and managed. Also moved the script runner to its own class so that we can mock it into the managed controller. Adding a ICommand interface and factory that we can use to mock Commands and avoid actually running them in unit tests.
2016-02-10 00:35:43 +00:00
// Copyright (c) .NET Foundation and contributors. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
using System;
using System.Collections.Generic;
using System.IO;
using Microsoft.DotNet.ProjectModel;
using Moq;
using NuGet.Frameworks;
using Xunit;
using Microsoft.DotNet.Cli.Utils;
using FluentAssertions;
using System.Linq;
Replacing the fixed rid in the dotnet compile unit test by one that respects the platform where the tests are running. Removing trailing slashes for the paths passed to the scripts to avoid the double quotes escaped issue.
2016-02-11 01:23:53 +00:00
using Microsoft.Extensions.PlatformAbstractions;
Refactoring dotnet-compile to make adding the script variable testable. So far, moved it to have a compiler controller and two separate compilers: native and managed. Also moved the script runner to its own class so that we can mock it into the managed controller. Adding a ICommand interface and factory that we can use to mock Commands and avoid actually running them in unit tests.
2016-02-10 00:35:43 +00:00
namespace Microsoft.DotNet.Tools.Compiler.Tests
{
public class GivenThatICareAboutScriptVariablesFromAManagedCompiler : IClassFixture<ScriptVariablesFixture>
{
private readonly ScriptVariablesFixture _fixture;
public GivenThatICareAboutScriptVariablesFromAManagedCompiler(ScriptVariablesFixture fixture)
{
_fixture = fixture;
}
update compiler unit tests fix rebase errors PR Feedback more PR feedback fix make new script file executable Remove scripts from TestAppCompilationContext add hashbang to echoscript
2016-02-12 00:08:46 +00:00
[Fact]
public void It_passes_a_FullTargetFramework_variable_to_the_pre_compile_scripts()
{
_fixture.PreCompileScriptVariables.Should().ContainKey("compile:FullTargetFramework");
t Convert Test Assets to Microsoft.NETCore.App fix dotnet-compile-fsc failures fix test failures
2016-04-13 00:29:07 +00:00
_fixture.PreCompileScriptVariables["compile:FullTargetFramework"].Should().Be(".NETCoreApp,Version=v1.0");
update compiler unit tests fix rebase errors PR Feedback more PR feedback fix make new script file executable Remove scripts from TestAppCompilationContext add hashbang to echoscript
2016-02-12 00:08:46 +00:00
}
Refactoring dotnet-compile to make adding the script variable testable. So far, moved it to have a compiler controller and two separate compilers: native and managed. Also moved the script runner to its own class so that we can mock it into the managed controller. Adding a ICommand interface and factory that we can use to mock Commands and avoid actually running them in unit tests.
2016-02-10 00:35:43 +00:00
[Fact]
public void It_passes_a_TargetFramework_variable_to_the_pre_compile_scripts()
{
_fixture.PreCompileScriptVariables.Should().ContainKey("compile:TargetFramework");
t Convert Test Assets to Microsoft.NETCore.App fix dotnet-compile-fsc failures fix test failures
2016-04-13 00:29:07 +00:00
_fixture.PreCompileScriptVariables["compile:TargetFramework"].Should().Be("netcoreapp1.0");
Refactoring dotnet-compile to make adding the script variable testable. So far, moved it to have a compiler controller and two separate compilers: native and managed. Also moved the script runner to its own class so that we can mock it into the managed controller. Adding a ICommand interface and factory that we can use to mock Commands and avoid actually running them in unit tests.
2016-02-10 00:35:43 +00:00
}
[Fact]
public void It_passes_a_Configuration_variable_to_the_pre_compile_scripts()
{
_fixture.PreCompileScriptVariables.Should().ContainKey("compile:Configuration");
_fixture.PreCompileScriptVariables["compile:Configuration"].Should().Be(
ScriptVariablesFixture.ConfigValue);
}
[Fact]
public void It_passes_a_OutputFile_variable_to_the_pre_compile_scripts()
{
_fixture.PreCompileScriptVariables.Should().ContainKey("compile:OutputFile");
_fixture.PreCompileScriptVariables["compile:OutputFile"].Should().Be(ScriptVariablesFixture.OutputFile);
}
[Fact]
public void It_passes_a_OutputDir_variable_to_the_pre_compile_scripts()
{
_fixture.PreCompileScriptVariables.Should().ContainKey("compile:OutputDir");
_fixture.PreCompileScriptVariables["compile:OutputDir"].Should().Be(ScriptVariablesFixture.OutputPath);
}
[Fact]
public void It_passes_a_ResponseFile_variable_to_the_pre_compile_scripts()
{
_fixture.PreCompileScriptVariables.Should().ContainKey("compile:ResponseFile");
_fixture.PreCompileScriptVariables["compile:ResponseFile"].Should().Be(ScriptVariablesFixture.ResponseFile);
}
[Fact]
public void It_passes_a_RuntimeOutputDir_variable_to_the_pre_compile_scripts_if_rid_is_set_in_the_ProjectContext()
{
Replacing the fixed rid in the dotnet compile unit test by one that respects the platform where the tests are running. Removing trailing slashes for the paths passed to the scripts to avoid the double quotes escaped issue.
2016-02-11 01:23:53 +00:00
var rid = PlatformServices.Default.Runtime.GetLegacyRestoreRuntimeIdentifier();
var fixture = ScriptVariablesFixture.GetFixtureWithRids(rid);
Refactoring dotnet-compile to make adding the script variable testable. So far, moved it to have a compiler controller and two separate compilers: native and managed. Also moved the script runner to its own class so that we can mock it into the managed controller. Adding a ICommand interface and factory that we can use to mock Commands and avoid actually running them in unit tests.
2016-02-10 00:35:43 +00:00
fixture.PreCompileScriptVariables.Should().ContainKey("compile:RuntimeOutputDir");
Replacing the fixed rid in the dotnet compile unit test by one that respects the platform where the tests are running. Removing trailing slashes for the paths passed to the scripts to avoid the double quotes escaped issue.
2016-02-11 01:23:53 +00:00
fixture.PreCompileScriptVariables["compile:RuntimeOutputDir"].Should().Be(fixture.RuntimeOutputDir);
Refactoring dotnet-compile to make adding the script variable testable. So far, moved it to have a compiler controller and two separate compilers: native and managed. Also moved the script runner to its own class so that we can mock it into the managed controller. Adding a ICommand interface and factory that we can use to mock Commands and avoid actually running them in unit tests.
2016-02-10 00:35:43 +00:00
}
update compiler unit tests fix rebase errors PR Feedback more PR feedback fix make new script file executable Remove scripts from TestAppCompilationContext add hashbang to echoscript
2016-02-12 00:08:46 +00:00
[Fact]
public void It_passes_a_FullTargetFramework_variable_to_the_post_compile_scripts()
{
_fixture.PostCompileScriptVariables.Should().ContainKey("compile:FullTargetFramework");
t Convert Test Assets to Microsoft.NETCore.App fix dotnet-compile-fsc failures fix test failures
2016-04-13 00:29:07 +00:00
_fixture.PostCompileScriptVariables["compile:FullTargetFramework"].Should().Be(".NETCoreApp,Version=v1.0");
update compiler unit tests fix rebase errors PR Feedback more PR feedback fix make new script file executable Remove scripts from TestAppCompilationContext add hashbang to echoscript
2016-02-12 00:08:46 +00:00
}
Refactoring dotnet-compile to make adding the script variable testable. So far, moved it to have a compiler controller and two separate compilers: native and managed. Also moved the script runner to its own class so that we can mock it into the managed controller. Adding a ICommand interface and factory that we can use to mock Commands and avoid actually running them in unit tests.
2016-02-10 00:35:43 +00:00
[Fact]
public void It_passes_a_TargetFramework_variable_to_the_post_compile_scripts()
{
_fixture.PostCompileScriptVariables.Should().ContainKey("compile:TargetFramework");
t Convert Test Assets to Microsoft.NETCore.App fix dotnet-compile-fsc failures fix test failures
2016-04-13 00:29:07 +00:00
_fixture.PostCompileScriptVariables["compile:TargetFramework"].Should().Be("netcoreapp1.0");
Refactoring dotnet-compile to make adding the script variable testable. So far, moved it to have a compiler controller and two separate compilers: native and managed. Also moved the script runner to its own class so that we can mock it into the managed controller. Adding a ICommand interface and factory that we can use to mock Commands and avoid actually running them in unit tests.
2016-02-10 00:35:43 +00:00
}
[Fact]
public void It_passes_a_Configuration_variable_to_the_post_compile_scripts()
{
_fixture.PostCompileScriptVariables.Should().ContainKey("compile:Configuration");
_fixture.PostCompileScriptVariables["compile:Configuration"].Should().Be(
ScriptVariablesFixture.ConfigValue);
}
[Fact]
public void It_passes_a_OutputFile_variable_to_the_post_compile_scripts()
{
_fixture.PostCompileScriptVariables.Should().ContainKey("compile:OutputFile");
_fixture.PostCompileScriptVariables["compile:OutputFile"].Should().Be(ScriptVariablesFixture.OutputFile);
}
[Fact]
public void It_passes_a_OutputDir_variable_to_the_post_compile_scripts()
{
_fixture.PostCompileScriptVariables.Should().ContainKey("compile:OutputDir");
_fixture.PostCompileScriptVariables["compile:OutputDir"].Should().Be(ScriptVariablesFixture.OutputPath);
}
[Fact]
public void It_passes_a_ResponseFile_variable_to_the_post_compile_scripts()
{
_fixture.PostCompileScriptVariables.Should().ContainKey("compile:ResponseFile");
_fixture.PostCompileScriptVariables["compile:ResponseFile"].Should().Be(ScriptVariablesFixture.ResponseFile);
}
[Fact]
public void It_passes_a_CompilerExitCode_variable_to_the_post_compile_scripts()
{
_fixture.PostCompileScriptVariables.Should().ContainKey("compile:CompilerExitCode");
_fixture.PostCompileScriptVariables["compile:CompilerExitCode"].Should().Be("0");
}
[Fact]
public void It_passes_a_RuntimeOutputDir_variable_to_the_post_compile_scripts_if_rid_is_set_in_the_ProjectContext()
{
Replacing the fixed rid in the dotnet compile unit test by one that respects the platform where the tests are running. Removing trailing slashes for the paths passed to the scripts to avoid the double quotes escaped issue.
2016-02-11 01:23:53 +00:00
var rid = PlatformServices.Default.Runtime.GetLegacyRestoreRuntimeIdentifier();
var fixture = ScriptVariablesFixture.GetFixtureWithRids(rid);
Refactoring dotnet-compile to make adding the script variable testable. So far, moved it to have a compiler controller and two separate compilers: native and managed. Also moved the script runner to its own class so that we can mock it into the managed controller. Adding a ICommand interface and factory that we can use to mock Commands and avoid actually running them in unit tests.
2016-02-10 00:35:43 +00:00
fixture.PostCompileScriptVariables.Should().ContainKey("compile:RuntimeOutputDir");
Replacing the fixed rid in the dotnet compile unit test by one that respects the platform where the tests are running. Removing trailing slashes for the paths passed to the scripts to avoid the double quotes escaped issue.
2016-02-11 01:23:53 +00:00
fixture.PostCompileScriptVariables["compile:RuntimeOutputDir"].Should().Be(fixture.RuntimeOutputDir);
Refactoring dotnet-compile to make adding the script variable testable. So far, moved it to have a compiler controller and two separate compilers: native and managed. Also moved the script runner to its own class so that we can mock it into the managed controller. Adding a ICommand interface and factory that we can use to mock Commands and avoid actually running them in unit tests.
2016-02-10 00:35:43 +00:00
}
}
public class ScriptVariablesFixture
{
t Convert Test Assets to Microsoft.NETCore.App fix dotnet-compile-fsc failures fix test failures
2016-04-13 00:29:07 +00:00
public readonly NuGetFramework TestAssetFramework = FrameworkConstants.CommonFrameworks.NetCoreApp10;
Refactoring dotnet-compile to make adding the script variable testable. So far, moved it to have a compiler controller and two separate compilers: native and managed. Also moved the script runner to its own class so that we can mock it into the managed controller. Adding a ICommand interface and factory that we can use to mock Commands and avoid actually running them in unit tests.
2016-02-10 00:35:43 +00:00
public const string ConfigValue = "Debug";
public static string TestAssetPath = Path.Combine(
AppContext.BaseDirectory,
"TestAssets",
"TestProjects",
Rebase with the latest sources and fix the tests.
2016-02-16 19:26:40 +00:00
"TestAppWithLibrary",
Refactoring dotnet-compile to make adding the script variable testable. So far, moved it to have a compiler controller and two separate compilers: native and managed. Also moved the script runner to its own class so that we can mock it into the managed controller. Adding a ICommand interface and factory that we can use to mock Commands and avoid actually running them in unit tests.
2016-02-10 00:35:43 +00:00
"TestApp");
public static string OutputPath = Path.Combine(
TestAssetPath,
"bin",
ConfigValue,
t Convert Test Assets to Microsoft.NETCore.App fix dotnet-compile-fsc failures fix test failures
2016-04-13 00:29:07 +00:00
"netcoreapp1.0");
Refactoring dotnet-compile to make adding the script variable testable. So far, moved it to have a compiler controller and two separate compilers: native and managed. Also moved the script runner to its own class so that we can mock it into the managed controller. Adding a ICommand interface and factory that we can use to mock Commands and avoid actually running them in unit tests.
2016-02-10 00:35:43 +00:00
Replacing the fixed rid in the dotnet compile unit test by one that respects the platform where the tests are running. Removing trailing slashes for the paths passed to the scripts to avoid the double quotes escaped issue.
2016-02-11 01:23:53 +00:00
public string RuntimeOutputDir { get; private set; }
Refactoring dotnet-compile to make adding the script variable testable. So far, moved it to have a compiler controller and two separate compilers: native and managed. Also moved the script runner to its own class so that we can mock it into the managed controller. Adding a ICommand interface and factory that we can use to mock Commands and avoid actually running them in unit tests.
2016-02-10 00:35:43 +00:00
public static string OutputFile = Path.Combine(OutputPath, "TestApp.dll");
public static string ResponseFile = Path.Combine(
TestAssetPath,
"obj",
ConfigValue,
t Convert Test Assets to Microsoft.NETCore.App fix dotnet-compile-fsc failures fix test failures
2016-04-13 00:29:07 +00:00
"netcoreapp1.0",
Refactoring dotnet-compile to make adding the script variable testable. So far, moved it to have a compiler controller and two separate compilers: native and managed. Also moved the script runner to its own class so that we can mock it into the managed controller. Adding a ICommand interface and factory that we can use to mock Commands and avoid actually running them in unit tests.
2016-02-10 00:35:43 +00:00
"dotnet-compile.rsp");
public Dictionary<string, string> PreCompileScriptVariables { get; private set; }
public Dictionary<string, string> PostCompileScriptVariables { get; private set; }
Replacing the fixed rid in the dotnet compile unit test by one that respects the platform where the tests are running. Removing trailing slashes for the paths passed to the scripts to avoid the double quotes escaped issue.
2016-02-11 01:23:53 +00:00
public ScriptVariablesFixture() : this(string.Empty)
Refactoring dotnet-compile to make adding the script variable testable. So far, moved it to have a compiler controller and two separate compilers: native and managed. Also moved the script runner to its own class so that we can mock it into the managed controller. Adding a ICommand interface and factory that we can use to mock Commands and avoid actually running them in unit tests.
2016-02-10 00:35:43 +00:00
{
}
Replacing the fixed rid in the dotnet compile unit test by one that respects the platform where the tests are running. Removing trailing slashes for the paths passed to the scripts to avoid the double quotes escaped issue.
2016-02-11 01:23:53 +00:00
private ScriptVariablesFixture(string rid)
Refactoring dotnet-compile to make adding the script variable testable. So far, moved it to have a compiler controller and two separate compilers: native and managed. Also moved the script runner to its own class so that we can mock it into the managed controller. Adding a ICommand interface and factory that we can use to mock Commands and avoid actually running them in unit tests.
2016-02-10 00:35:43 +00:00
{
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>>(),
Pipe configuration through CommandResolver script changes to pipe configuration to test.ps1 debug commit, remove this commit Change dotnet-test to invoke dotnet-test-xunit directly build tests with configuration, framework, runtime in windows Update testtargets in new build scripts make configuration first arg to dotnet test PR Feedback update command factory fix interface test update
2016-02-06 02:55:15 +00:00
It.IsAny<NuGetFramework>(),
It.IsAny<string>()))
Refactoring dotnet-compile to make adding the script variable testable. So far, moved it to have a compiler controller and two separate compilers: native and managed. Also moved the script runner to its own class so that we can mock it into the managed controller. Adding a ICommand interface and factory that we can use to mock Commands and avoid actually running them in unit tests.
2016-02-10 00:35:43 +00:00
.Returns(command.Object);
Memory usage improvements in build (#2626) * Use a WorkspaceContext in dotnet-build to cache project data across multiple compilations in a single build action * Dramatically reduce string and object duplication by introducing a "Symbol Table" that shares instances of NuGetVersion, NuGetFramework, VersionRange and string across multiple lock-file parses Test Results: * Testing was done by compiling Microsoft.AspNetCore.Mvc (and it's dependencies) and taking memory snapshots after each compilation in dotMemory * We used to allocate ~3MB and deallocate ~2.5MB on EACH compilation in a single build action. This has been reduced to ~120KB allocated/deallocated * After introducing WorkspaceContext, total memory usage spiked from 6MB across the whole build action to about 13MB, introducing the symbol table dropped it back to about 5-6MB.
2016-04-22 22:01:56 +00:00
var _args = new BuildCommandApp("dotnet compile", ".NET Compiler", "Compiler for the .NET Platform", WorkspaceContext.Create(designTime: false));
Refactoring dotnet-compile to make adding the script variable testable. So far, moved it to have a compiler controller and two separate compilers: native and managed. Also moved the script runner to its own class so that we can mock it into the managed controller. Adding a ICommand interface and factory that we can use to mock Commands and avoid actually running them in unit tests.
2016-02-10 00:35:43 +00:00
_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);
Replacing the fixed rid in the dotnet compile unit test by one that respects the platform where the tests are running. Removing trailing slashes for the paths passed to the scripts to avoid the double quotes escaped issue.
2016-02-11 01:23:53 +00:00
var rids = new List<string>();
if (!string.IsNullOrEmpty(rid))
{
rids.Add(rid);
}
Memory usage improvements in build (#2626) * Use a WorkspaceContext in dotnet-build to cache project data across multiple compilations in a single build action * Dramatically reduce string and object duplication by introducing a "Symbol Table" that shares instances of NuGetVersion, NuGetFramework, VersionRange and string across multiple lock-file parses Test Results: * Testing was done by compiling Microsoft.AspNetCore.Mvc (and it's dependencies) and taking memory snapshots after each compilation in dotMemory * We used to allocate ~3MB and deallocate ~2.5MB on EACH compilation in a single build action. This has been reduced to ~120KB allocated/deallocated * After introducing WorkspaceContext, total memory usage spiked from 6MB across the whole build action to about 13MB, introducing the symbol table dropped it back to about 5-6MB.
2016-04-22 22:01:56 +00:00
var workspace = WorkspaceContext.Create(ProjectReaderSettings.ReadFromEnvironment(), designTime: false);
var context = workspace.GetProjectContext(projectJson, TestAssetFramework, rids);
Refactoring dotnet-compile to make adding the script variable testable. So far, moved it to have a compiler controller and two separate compilers: native and managed. Also moved the script runner to its own class so that we can mock it into the managed controller. Adding a ICommand interface and factory that we can use to mock Commands and avoid actually running them in unit tests.
2016-02-10 00:35:43 +00:00
managedCompiler.Compile(context, _args);
Replacing the fixed rid in the dotnet compile unit test by one that respects the platform where the tests are running. Removing trailing slashes for the paths passed to the scripts to avoid the double quotes escaped issue.
2016-02-11 01:23:53 +00:00
RuntimeOutputDir = Path.Combine(OutputPath, rid);
Refactoring dotnet-compile to make adding the script variable testable. So far, moved it to have a compiler controller and two separate compilers: native and managed. Also moved the script runner to its own class so that we can mock it into the managed controller. Adding a ICommand interface and factory that we can use to mock Commands and avoid actually running them in unit tests.
2016-02-10 00:35:43 +00:00
}
Replacing the fixed rid in the dotnet compile unit test by one that respects the platform where the tests are running. Removing trailing slashes for the paths passed to the scripts to avoid the double quotes escaped issue.
2016-02-11 01:23:53 +00:00
public static ScriptVariablesFixture GetFixtureWithRids(string rid)
Refactoring dotnet-compile to make adding the script variable testable. So far, moved it to have a compiler controller and two separate compilers: native and managed. Also moved the script runner to its own class so that we can mock it into the managed controller. Adding a ICommand interface and factory that we can use to mock Commands and avoid actually running them in unit tests.
2016-02-10 00:35:43 +00:00
{
Replacing the fixed rid in the dotnet compile unit test by one that respects the platform where the tests are running. Removing trailing slashes for the paths passed to the scripts to avoid the double quotes escaped issue.
2016-02-11 01:23:53 +00:00
return new ScriptVariablesFixture(rid);
Refactoring dotnet-compile to make adding the script variable testable. So far, moved it to have a compiler controller and two separate compilers: native and managed. Also moved the script runner to its own class so that we can mock it into the managed controller. Adding a ICommand interface and factory that we can use to mock Commands and avoid actually running them in unit tests.
2016-02-10 00:35:43 +00:00
}
}
}
Reference in a new issue Copy permalink