mirrors/dotnet-installer
Archived
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages 1 Wiki Activity Actions
This repository has been archived on 2025-09-07. You can view files and clone it, but you cannot make any changes to it's state, such as pushing and creating new issues, pull requests or comments.
dotnet-installer/test/dotnet-compile.UnitTests/GivenThatICareAboutScriptVariablesFromAManagedCompiler.cs

235 lines
9.9 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-09 16:35:43 -08: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;
Replaces references to Microsoft.Extensions.PlatformAbstractions with Microsoft.Extensions.PlatformAbstractions.Internal
2016-04-28 16:30:32 -07:00
using FluentAssertions;
using Microsoft.DotNet.Cli.Utils;
using Microsoft.DotNet.InternalAbstractions;
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-09 16:35:43 -08:00
using Microsoft.DotNet.ProjectModel;
using Moq;
using NuGet.Frameworks;
using Xunit;
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-11 16:08:46 -08: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-12 17:29:07 -07: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-11 16:08:46 -08: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-09 16:35:43 -08: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-12 17:29:07 -07: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-09 16:35:43 -08: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()
{
Replaces references to Microsoft.Extensions.PlatformAbstractions with Microsoft.Extensions.PlatformAbstractions.Internal
2016-04-28 16:30:32 -07:00
var rid = RuntimeEnvironmentRidExtensions.GetLegacyRestoreRuntimeIdentifier();
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-10 17:23:53 -08:00
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-09 16:35:43 -08: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-10 17:23:53 -08: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-09 16:35:43 -08: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-11 16:08:46 -08: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-12 17:29:07 -07: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-11 16:08:46 -08: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-09 16:35:43 -08: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-12 17:29:07 -07: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-09 16:35:43 -08: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()
{
Replaces references to Microsoft.Extensions.PlatformAbstractions with Microsoft.Extensions.PlatformAbstractions.Internal
2016-04-28 16:30:32 -07:00
var rid = RuntimeEnvironmentRidExtensions.GetLegacyRestoreRuntimeIdentifier();
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-10 17:23:53 -08:00
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-09 16:35:43 -08: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-10 17:23:53 -08: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-09 16:35:43 -08:00
}
}
public class ScriptVariablesFixture
{
t Convert Test Assets to Microsoft.NETCore.App fix dotnet-compile-fsc failures fix test failures
2016-04-12 17:29:07 -07: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-09 16:35:43 -08: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 11:26:40 -08: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-09 16:35:43 -08: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-12 17:29:07 -07: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-09 16:35:43 -08: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-10 17:23:53 -08: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-09 16:35:43 -08: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-12 17:29:07 -07: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-09 16:35:43 -08: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-10 17:23:53 -08: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-09 16:35:43 -08: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-10 17:23:53 -08: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-09 16:35:43 -08: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-05 18:55:15 -08: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-09 16:35:43 -08:00
.Returns(command.Object);
refactor WorkspaceContext (#2736) this removes a regression in ProjectModelServer behavior also added a test to cover target framework change in DTH
2016-05-02 11:32:24 -07:00
var _args = new BuildCommandApp("dotnet compile", ".NET Compiler", "Compiler for the .NET Platform", new BuildWorkspace(new ProjectReaderSettings()));
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-09 16:35:43 -08: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-10 17:23:53 -08:00
var rids = new List<string>();
if (!string.IsNullOrEmpty(rid))
{
rids.Add(rid);
}
refactor WorkspaceContext (#2736) this removes a regression in ProjectModelServer behavior also added a test to cover target framework change in DTH
2016-05-02 11:32:24 -07:00
var workspace = new BuildWorkspace(new ProjectReaderSettings());
align code in dotnet-run (#2679) we used to use different code when --framework was specified than when it was not specified, this synchronizes them to use the same code path which removes a hidden NullRef also adds tests to cover both cases
2016-04-25 13:53:02 -07:00
var context = workspace.GetRuntimeContext(workspace.GetProjectContext(projectJson, TestAssetFramework), rids);
context = workspace.GetRuntimeContext(context, 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-09 16:35:43 -08: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-10 17:23:53 -08: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-09 16:35:43 -08: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-10 17:23:53 -08: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-09 16:35:43 -08: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-10 17:23:53 -08: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-09 16:35:43 -08:00
}
}
}
Reference in a new issue Copy permalink