Add support for filtering out enviornment variables in tests

Only enabled for OPENSSL_CONF for now.

See: #51

Samples/PassingBashTestWithEnvironmentVariables/test.json

@@ -0,0 +1,12 @@
+{
+ "name": "PassingBashTestWithEnvironmentVariables",
+ "enabled": true,
+ "requiresSdk": true,
+ "version": "1.0",
+ "versionSpecific": false,
+ "type": "bash",
+ "cleanup": true,
+ "ignoredRIDs":[
+ ]
+}
+

Samples/PassingBashTestWithEnvironmentVariables/test.sh

@@ -0,0 +1,8 @@
+#!/bin/bash
+
+env
+
+if [[ -n "${OPENSSL_CONF}" ]]; then
+ echo "error: OPENSSL_CONF should never be set"
+ exit 1
+fi

Samples/PassingXUnitTestWithEnvironmentVariables/PassingXUnitTestWithEnvironmentVariables.cs

@@ -0,0 +1,14 @@
+using System;
+using Xunit;
+
+namespace Samples
+{
+ public class PassingXUnitTestWithEnvironmentVariables
+ {
+ [Fact]
+ public void Test1()
+ {
+ Assert.Null(Environment.GetEnvironmentVariable("OPENSSL_CONF"));
+ }
+ }
+}

Samples/PassingXUnitTestWithEnvironmentVariables/PassingXUnitTestWithEnvironmentVariables.csproj

@@ -0,0 +1,17 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+ <PropertyGroup>
+ <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+ <TargetFramework>netcoreapp3.1</TargetFramework>
+
+ <IsPackable>false</IsPackable>
+ </PropertyGroup>
+
+ <ItemGroup>
+ <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.5.0" />
+ <PackageReference Include="xunit" Version="2.3.1" />
+ <PackageReference Include="xunit.runner.visualstudio" Version="2.3.1" />
+ <DotNetCliToolReference Include="dotnet-xunit" Version="2.3.1" />
+ </ItemGroup>
+
+</Project>

Samples/PassingXUnitTestWithEnvironmentVariables/test.json

@@ -0,0 +1,12 @@
+{
+ "name": "PassingXUnitTestWithEnvironmentVariables",
+ "enabled": true,
+ "requiresSdk": true,
+ "version": "1.0",
+ "versionSpecific": false,
+ "type": "xunit",
+ "cleanup": true,
+ "ignoredRIDs":[
+ ]
+}
+

Turkey.Tests/EnvironmentVariableSanitizerTest.cs

@@ -0,0 +1,54 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+
+using Xunit;
+
+namespace Turkey.Tests
+{
+ public class EnvironmentVariableSanitizerTest
+ {
+ [Theory]
+ // TODO enable these too
+ // [InlineData("ASPNETCORE_URLS")]
+ // [InlineData("COREHOST_TRACE")]
+ // [InlineData("DOTNET_FOO_BAR")]
+ // [InlineData("DOTNET_ROLL_FORWARD")]
+ // [InlineData("DOTNET_RUNTIME_ID")]
+ // [InlineData("DOTNET_STARTUP_HOOKS")]
+ // [InlineData("NUGET_PACKAGES")]
+ [InlineData("OPENSSL_CONF")]
+ public void EnvironmentVariablesAreRemoved(string name)
+ {
+ var environment = new Dictionary<string, string>()
+ {
+ { name, "foobar" },
+ };
+
+ var sanitizer = new EnvironmentVariableSanitizer();
+ var result = sanitizer.SanitizeEnvironmentVariables(environment);
+
+ Assert.DoesNotContain(name, result.Keys);
+ }
+
+ [InlineData("DOTNET_ROOT")]
+ [InlineData("DOTNET_CLI_TELEMETRY_OPTOUT")]
+ [InlineData("PATH")]
+ [InlineData("USER")]
+ [InlineData("HOME")]
+ public void EnvironmentVariablesAreKept(string name)
+ {
+ var environment = new Dictionary<string, string>()
+ {
+ { name, "foobar" },
+ };
+
+ var sanitizer = new EnvironmentVariableSanitizer();
+ var result = sanitizer.SanitizeEnvironmentVariables(environment);
+
+ Assert.Contains(name, result.Keys);
+
+ }
+ }
+}

Turkey.Tests/TestParserTest.cs

@@ -12,7 +12,7 @@ public class TestParserTests
  public void DisabledTestShouldBeSkipped()
  {
  TestParser parser = new TestParser();
- SystemUnderTest system = new SystemUnderTest(null, null, null);
+ SystemUnderTest system = new SystemUnderTest(null, null, null, null);
  TestDescriptor test = new TestDescriptor()
  {
  Enabled = false,
@@ -41,7 +41,8 @@ public void TestShouldBeRunForSameOrHigherVersions(string version, bool expected
  SystemUnderTest system = new SystemUnderTest(
  runtimeVersion: Version.Parse(version),
  sdkVersion: null,
- platformIds: new List<string>());
+ platformIds: new List<string>(),
+ environmentVariables: null);
 
  TestDescriptor test = new TestDescriptor()
  {
@@ -75,7 +76,8 @@ public void VersionSpecificTestShouldBeRunForSameMajorMinorVersion(string versio
  SystemUnderTest system = new SystemUnderTest(
  runtimeVersion: Version.Parse(version),
  sdkVersion: null,
- platformIds: new List<string>());
+ platformIds: new List<string>(),
+ environmentVariables: null);
  TestDescriptor test = new TestDescriptor()
  {
  Enabled = true,
@@ -111,7 +113,8 @@ public void VersionSpecificTestWithWildcardShouldBeRunForSameMajorVersion(string
  SystemUnderTest system = new SystemUnderTest(
  runtimeVersion: Version.Parse(version),
  sdkVersion: null,
- platformIds: new List<string>());
+ platformIds: new List<string>(),
+ environmentVariables: null);
  TestDescriptor test = new TestDescriptor()
  {
  Enabled = true,
@@ -132,7 +135,8 @@ public void MissingIgnoredRIDsIsOkay()
  SystemUnderTest system = new SystemUnderTest(
  runtimeVersion: Version.Parse("2.1"),
  sdkVersion: null,
- platformIds: new string[] { "linux" }.ToList());
+ platformIds: new string[] { "linux" }.ToList(),
+ environmentVariables: null);
  TestDescriptor test = new TestDescriptor()
  {
  Enabled = true,
@@ -159,7 +163,8 @@ public void TestShouldNotRunOnIgnoredPlatforms(string[] currentPlatforms, string
  SystemUnderTest system = new SystemUnderTest(
  runtimeVersion: Version.Parse("2.1"),
  sdkVersion: null,
- platformIds: currentPlatforms.ToList());
+ platformIds: currentPlatforms.ToList(),
+ environmentVariables: null);
  TestDescriptor test = new TestDescriptor()
  {
  Enabled = true,
@@ -183,7 +188,8 @@ public void SdkTestsShouldRunOnlyWithSdk(string sdkVersion, bool requiresSdk, bo
  SystemUnderTest system = new SystemUnderTest(
  runtimeVersion: Version.Parse("3.1"),
  sdkVersion: Version.Parse(sdkVersion),
- platformIds: new List<string>());
+ platformIds: new List<string>(),
+ environmentVariables: null);
  TestDescriptor test = new TestDescriptor()
  {
  Enabled = true,

Turkey/BashTest.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Diagnostics;
 using System.IO;
 using System.Threading;
@@ -36,6 +37,13 @@ protected override async Task<TestResult> InternalRunAsync(CancellationToken can
  RedirectStandardOutput = true,
  RedirectStandardError = true,
  };
+
+ startInfo.EnvironmentVariables.Clear();
+ foreach (var (key, value) in SystemUnderTest.EnvironmentVariables)
+ {
+ startInfo.EnvironmentVariables.Add(key, value);
+ }
+
  standardOutputWriter.WriteLine($"Executing {startInfo.FileName} with arguments {startInfo.Arguments} in working directory {startInfo.WorkingDirectory}");
  using (Process p = Process.Start(startInfo))
  {

Turkey/DotNet.cs

@@ -93,7 +93,7 @@ public ProcessResult(int exitCode, string stdout, string stderr)
  }
  }
 
- public static async Task<ProcessResult> BuildAsync(DirectoryInfo workingDirectory, CancellationToken token)
+ public static async Task<ProcessResult> BuildAsync(DirectoryInfo workingDirectory, IReadOnlyDictionary<string, string> environment, CancellationToken token)
  {
  var arguments = new string[]
  {
@@ -102,21 +102,21 @@ public static async Task<ProcessResult> BuildAsync(DirectoryInfo workingDirector
  "-p:UseSharedCompilation=false",
  "-m:1",
  };
- var result = await RunDotNetCommandAsync(workingDirectory, arguments, token);
+ var result = await RunDotNetCommandAsync(workingDirectory, arguments, environment, token);
  return result;
  }
 
- public static async Task<ProcessResult> RunAsync(DirectoryInfo workingDirectory, CancellationToken token)
+ public static async Task<ProcessResult> RunAsync(DirectoryInfo workingDirectory, IReadOnlyDictionary<string, string> environment, CancellationToken token)
  {
- return await RunDotNetCommandAsync(workingDirectory, new string[] { "run", "--no-restore", "--no-build"} , token);
+ return await RunDotNetCommandAsync(workingDirectory, new string[] { "run", "--no-restore", "--no-build"} , environment, token);
  }
 
- public static async Task<ProcessResult> TestAsync(DirectoryInfo workingDirectory, CancellationToken token)
+ public static async Task<ProcessResult> TestAsync(DirectoryInfo workingDirectory, IReadOnlyDictionary<string, string> environment, CancellationToken token)
  {
- return await RunDotNetCommandAsync(workingDirectory, new string[] { "test", "--no-restore", "--no-build"} , token);
+ return await RunDotNetCommandAsync(workingDirectory, new string[] { "test", "--no-restore", "--no-build"} , environment, token);
  }
 
- private static async Task<ProcessResult> RunDotNetCommandAsync(DirectoryInfo workingDirectory, string[] commands, CancellationToken token)
+ private static async Task<ProcessResult> RunDotNetCommandAsync(DirectoryInfo workingDirectory, string[] commands, IReadOnlyDictionary<string, string> environment, CancellationToken token)
  {
  var arguments = string.Join(" ", commands);
  ProcessStartInfo startInfo = new ProcessStartInfo()
@@ -128,6 +128,12 @@ private static async Task<ProcessResult> RunDotNetCommandAsync(DirectoryInfo wor
  RedirectStandardError = true,
  };
 
+ startInfo.EnvironmentVariables.Clear();
+ foreach (var (key, value) in environment)
+ {
+ startInfo.EnvironmentVariables.Add(key, value);
+ }
+
  using (var process = Process.Start(startInfo))
  {
  StringWriter standardOutputWriter = new StringWriter();

Turkey/EnvironmentVariableSanitizer.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Turkey
+{
+ public class EnvironmentVariableSanitizer
+ {
+ private readonly List<string> ToFilter = new List<string>()
+ {
+ "OPENSSL_CONF",
+ };
+
+ public Dictionary<string, string> SanitizeCurrentEnvironmentVariables()
+ {
+ return SanitizeEnvironmentVariables(Environment.GetEnvironmentVariables());
+ }
+
+ public Dictionary<string, string> SanitizeEnvironmentVariables(IDictionary environmentVariables)
+ {
+ var result = new Dictionary<string, string>();
+
+ foreach (DictionaryEntry entry in environmentVariables)
+ {
+ if (ToFilter.Contains((string)entry.Key))
+ {
+ continue;
+ }
+
+ result.Add((string)entry.Key, (string)entry.Value);
+ }
+
+ return result;
+ }
+ }
+}

Turkey/Program.cs

@@ -100,15 +100,20 @@ public static async Task<int> Run(string testRoot,
  List<string> platformIds = new PlatformId().CurrentIds;
  Console.WriteLine($"Current platform is: {string.Join(", ", platformIds)}");
 
+ var sanitizer = new EnvironmentVariableSanitizer();
+ var envVars = sanitizer.SanitizeCurrentEnvironmentVariables();
+
  SystemUnderTest system = new SystemUnderTest(
  runtimeVersion: dotnet.LatestRuntimeVersion,
  sdkVersion: dotnet.LatestSdkVersion,
- platformIds: platformIds
+ platformIds: platformIds,
+ environmentVariables: envVars
  );
 
  Version packageVersion = dotnet.LatestRuntimeVersion;
  string nuGetConfig = await GenerateNuGetConfigIfNeededAsync(additionalFeed, packageVersion);
 
+
  TestRunner runner = new TestRunner(
  cleaner: cleaner,
  system: system,

Turkey/TestRunner.cs

@@ -21,12 +21,14 @@ public class SystemUnderTest
  public Version RuntimeVersion { get; }
  public Version SdkVersion { get; }
  public List<string> CurrentPlatformIds { get; }
+ public IReadOnlyDictionary<string, string> EnvironmentVariables;
 
- public SystemUnderTest(Version runtimeVersion, Version sdkVersion, List<string> platformIds)
+ public SystemUnderTest(Version runtimeVersion, Version sdkVersion, List<string> platformIds, IReadOnlyDictionary<string, string> environmentVariables)
  {
  RuntimeVersion = runtimeVersion;
  SdkVersion = sdkVersion;
  CurrentPlatformIds = platformIds;
+ EnvironmentVariables = environmentVariables;
  }
  }
 

Turkey/XUnitTest.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.IO;
 using System.Threading;
 using System.Threading.Tasks;
@@ -47,12 +48,12 @@ protected override async Task<TestResult> InternalRunAsync(CancellationToken can
 
  private async Task<PartialResult> BuildProjectAsync(CancellationToken token)
  {
- return ProcessResultToPartialResult(await DotNet.BuildAsync(Directory, token));
+ return ProcessResultToPartialResult(await DotNet.BuildAsync(Directory, SystemUnderTest.EnvironmentVariables, token));
  }
 
  private async Task<PartialResult> TestProjectAsync(CancellationToken token)
  {
- return ProcessResultToPartialResult(await DotNet.TestAsync(Directory, token));
+ return ProcessResultToPartialResult(await DotNet.TestAsync(Directory, SystemUnderTest.EnvironmentVariables, token));
  }
 
  private static PartialResult ProcessResultToPartialResult(DotNet.ProcessResult result)