pax_global_header 0000666 0000000 0000000 00000000064 14344615317 0014522 g ustar 00root root 0000000 0000000 52 comment=ec4b2b1f6f39514caca51a81273edf7376899a60
Light.Xunit-1.0.0/ 0000775 0000000 0000000 00000000000 14344615317 0013675 5 ustar 00root root 0000000 0000000 Light.Xunit-1.0.0/.github/ 0000775 0000000 0000000 00000000000 14344615317 0015235 5 ustar 00root root 0000000 0000000 Light.Xunit-1.0.0/.github/workflows/ 0000775 0000000 0000000 00000000000 14344615317 0017272 5 ustar 00root root 0000000 0000000 Light.Xunit-1.0.0/.github/workflows/build-and-test.yml 0000664 0000000 0000000 00000001117 14344615317 0022631 0 ustar 00root root 0000000 0000000 name: Build and Test
on:
push:
branches: [ "main" ]
pull_request:
branches: [ "main" ]
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- name: Setup .NET
uses: actions/setup-dotnet@v3
with:
dotnet-version: 7.0.x
- name: Restore dependencies
run: dotnet restore ./Code/Light.Xunit.sln
- name: Build
run: dotnet build ./Code/Light.Xunit.sln -c Release --no-restore
- name: Test
run: dotnet test ./Code/Light.Xunit.Tests/Light.Xunit.Tests.csproj -c Release --no-build --verbosity normal
Light.Xunit-1.0.0/.gitignore 0000664 0000000 0000000 00000000103 14344615317 0015657 0 ustar 00root root 0000000 0000000 .vs/
.vscode/
.idea/
bin/
obj/
*.user
Light.Xunit.Tests.Local.props Light.Xunit-1.0.0/Code/ 0000775 0000000 0000000 00000000000 14344615317 0014547 5 ustar 00root root 0000000 0000000 Light.Xunit-1.0.0/Code/Light.Xunit.Tests/ 0000775 0000000 0000000 00000000000 14344615317 0020025 5 ustar 00root root 0000000 0000000 Light.Xunit-1.0.0/Code/Light.Xunit.Tests/ExplicitTestOrderTests.cs 0000664 0000000 0000000 00000001504 14344615317 0025014 0 ustar 00root root 0000000 0000000 using FluentAssertions;
using Xunit;
namespace Light.Xunit.Tests;
[TestCaseOrderer(TestOrderer.TypeName, TestOrderer.AssemblyName)]
public static class ExplicitTestOrderTests
{
private static int Value { get; set; } = 1;
[Fact]
[TestOrder(4)]
public static void Test4()
{
Value.Should().Be(4);
Value = 5;
}
[Fact]
[TestOrder(1)]
[Trait("Category", "Some other trait")] // This attribute is here to ensure that any other trait still works
public static void Test1()
{
Value.Should().Be(1);
Value = 2;
}
[Fact]
[TestOrder(3)]
public static void Test3()
{
Value.Should().Be(3);
Value = 4;
}
[Fact]
[TestOrder(2)]
public static void Test2()
{
Value.Should().Be(2);
Value = 3;
}
} Light.Xunit-1.0.0/Code/Light.Xunit.Tests/ImplicitTestOrderTests.cs 0000664 0000000 0000000 00000001335 14344615317 0025007 0 ustar 00root root 0000000 0000000 using FluentAssertions;
using Xunit;
namespace Light.Xunit.Tests;
[TestCaseOrderer(TestOrderer.TypeName, TestOrderer.AssemblyName)]
public static class ImplicitTestOrderTests
{
private static int Value { get; set; } = 42;
[Fact]
public static void Test1()
{
Value.Should().Be(42);
Value = 3;
}
[Fact]
public static void Test2()
{
Value.Should().Be(3);
Value = 5;
}
[Fact]
public static void Test3()
{
Value.Should().Be(5);
Value = 1988;
}
[Fact]
public static void Test4()
{
Value.Should().Be(1988);
Value = -40102;
}
[Fact]
public static void Test5() => Value.Should().Be(-40102);
} Light.Xunit-1.0.0/Code/Light.Xunit.Tests/Light.Xunit.Tests.csproj 0000664 0000000 0000000 00000001530 14344615317 0024524 0 ustar 00root root 0000000 0000000
net7.0
enable
11.0
false
Light.Xunit-1.0.0/Code/Light.Xunit.Tests/OutputMock.cs 0000664 0000000 0000000 00000000545 14344615317 0022472 0 ustar 00root root 0000000 0000000 using System;
using Xunit.Abstractions;
namespace Light.Xunit.Tests;
public sealed class OutputMock : ITestOutputHelper
{
public string? CapturedMessage { get; private set; }
public void WriteLine(string message) => CapturedMessage = message;
public void WriteLine(string format, params object[] args) => throw new NotSupportedException();
} Light.Xunit-1.0.0/Code/Light.Xunit.Tests/TestSettingsTests.cs 0000664 0000000 0000000 00000007322 14344615317 0024043 0 ustar 00root root 0000000 0000000 using System;
using System.IO;
using FluentAssertions;
using Xunit;
namespace Light.Xunit.Tests;
public sealed class TestSettingsTests
{
public TestSettingsTests()
{
DeleteFileIfNecessary("testsettings.json");
DeleteFileIfNecessary("testsettings.Build.json");
DeleteFileIfNecessary("testsettings.Development.json");
}
[Fact]
public void LoadNoSettings() =>
TestSettings.LoadConfiguration().GetChildren().Should().BeEmpty();
[Fact]
public void LoadOnlyTestSettings()
{
File.WriteAllText("testsettings.json", "{ \"someValue\": \"Foo\" }");
var configuration = TestSettings.LoadConfiguration();
var someValue = configuration["someValue"];
someValue.Should().Be("Foo");
}
[Fact]
public void OverwriteValueInDevelopmentSettings()
{
File.WriteAllText("testsettings.json", "{ \"aValue\": \"Foo\" }");
File.WriteAllText("testsettings.Development.json", "{ \"aValue\": \"Bar\" }");
var configuration = TestSettings.LoadConfiguration();
var aValue = configuration["aValue"];
aValue.Should().Be("Bar");
}
[Fact]
public void IgnoreBuildSettingsWhenBuildServerModeIsOff()
{
File.WriteAllText("testsettings.json", "{ \"theValue\": \"Foo\" }");
File.WriteAllText("testsettings.Development.json", "{ \"theValue\": \"Bar\" }");
File.WriteAllText("testsettings.Build.json", "{ \"theValue\": \"Baz\" }");
var configuration = TestSettings.LoadConfiguration();
var theValue = configuration["theValue"];
theValue.Should().Be("Bar");
configuration.Providers.Should().HaveCount(2, "testSettings.Build.json was not loaded");
}
[Fact]
public void IgnoreDevelopmentSettingsWhenBuildServerModeIsOn()
{
File.WriteAllText("testsettings.json", "{ \"theValue\": \"Foo\" }");
File.WriteAllText("testsettings.Development.json", "{ \"theValue\": \"Bar\" }");
File.WriteAllText("testsettings.Build.json", "{ \"theValue\": \"Baz\" }");
var configuration = TestSettings.LoadConfiguration(isInBuildServerMode: true);
var theValue = configuration["theValue"];
theValue.Should().Be("Baz");
configuration.Providers.Should().HaveCount(2, "testsettings.Development.json was not loaded");
}
[Fact]
public void IncludeDevelopmentSettingsInBuildServerMode()
{
File.WriteAllText("testsettings.json", "{ \"theValue\": \"Foo\" }");
File.WriteAllText("testsettings.Development.json", "{ \"testConfiguration\": { \"loadDevelopmentSettingsFileInBuildServerMode\": true }, \"theValue\": \"Bar\" }");
File.WriteAllText("testsettings.Build.json", "{ \"theValue\": \"Baz\" }");
var configuration = TestSettings.LoadConfiguration(isInBuildServerMode: true);
var theValue = configuration["theValue"];
theValue.Should().Be("Bar");
configuration.Providers.Should().HaveCount(3, "all JSON file were included because of loadDevelopmentSettingsFileInBuildServerMode");
}
[Fact]
public void LoadEnvironmentVariables()
{
Environment.SetEnvironmentVariable("Xunit_TestVariable", "Foo", EnvironmentVariableTarget.Process);
File.WriteAllText("testsettings.json", "{ \"testConfiguration\": { \"loadEnvironmentVariables\": true, \"environmentVariablesPrefix\": \"Xunit_\" }, \"theValue\": \"Foo\" }");
var configuration = TestSettings.LoadConfiguration();
var environmentVariableValue = configuration["TestVariable"];
environmentVariableValue.Should().Be("Foo");
}
private static void DeleteFileIfNecessary(string filePath)
{
if (File.Exists(filePath))
File.Delete(filePath);
}
} Light.Xunit-1.0.0/Code/Light.Xunit.Tests/WriteExceptionToOutputTests.cs 0000664 0000000 0000000 00000001540 14344615317 0026074 0 ustar 00root root 0000000 0000000 using System;
using FluentAssertions;
using Xunit;
namespace Light.Xunit.Tests;
public sealed class WriteExceptionToOutputTests
{
private OutputMock Output { get; } = new ();
[Fact]
public void WriteExceptionToOutput()
{
var exception = new Exception();
exception.ShouldBeWrittenTo(Output);
Output.CapturedMessage.Should().Be(exception.ToString());
}
[Fact]
public static void OutputNull()
{
var act = () => new Exception().ShouldBeWrittenTo(null!);
act.Should().Throw()
.And.ParamName.Should().Be("output");
}
[Fact]
public void ExceptionNull()
{
var act = () => ((Exception) null!).ShouldBeWrittenTo(Output);
act.Should().Throw()
.And.ParamName.Should().Be("exception");
}
} Light.Xunit-1.0.0/Code/Light.Xunit.Tests/WriteStringToOutputTests.cs 0000664 0000000 0000000 00000001237 14344615317 0025407 0 ustar 00root root 0000000 0000000 using System;
using FluentAssertions;
using Xunit;
namespace Light.Xunit.Tests;
public sealed class WriteStringToOutputTests
{
private OutputMock Output { get; } = new ();
[Theory]
[InlineData("Foo")]
[InlineData("Bar")]
[InlineData("Baz")]
[InlineData("")]
public void WriteStringToOutput(string message)
{
message.ShouldBeWrittenTo(Output);
Output.CapturedMessage.Should().BeSameAs(message);
}
[Fact]
public static void OutputNull()
{
var act = () => "Foo".ShouldBeWrittenTo(null!);
act.Should().Throw()
.And.ParamName.Should().Be("output");
}
} Light.Xunit-1.0.0/Code/Light.Xunit.sln 0000664 0000000 0000000 00000003431 14344615317 0017443 0 ustar 00root root 0000000 0000000
Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio Version 17
VisualStudioVersion = 17.0.31903.59
MinimumVisualStudioVersion = 10.0.40219.1
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Light.Xunit", "Light.Xunit\Light.Xunit.csproj", "{1D19637D-C1E8-4A72-91DE-F7027D370543}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Light.Xunit.Tests", "Light.Xunit.Tests\Light.Xunit.Tests.csproj", "{57C9AB55-EA91-4F0E-B9C3-C9D9C1BB2FFE}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{03C5C0FE-69F2-45E3-90F5-D0BFC9E52F87}"
ProjectSection(SolutionItems) = preProject
..\.gitignore = ..\.gitignore
..\LICENSE = ..\LICENSE
..\light-logo.png = ..\light-logo.png
..\readme.md = ..\readme.md
EndProjectSection
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Any CPU = Debug|Any CPU
Release|Any CPU = Release|Any CPU
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{1D19637D-C1E8-4A72-91DE-F7027D370543}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{1D19637D-C1E8-4A72-91DE-F7027D370543}.Debug|Any CPU.Build.0 = Debug|Any CPU
{1D19637D-C1E8-4A72-91DE-F7027D370543}.Release|Any CPU.ActiveCfg = Release|Any CPU
{1D19637D-C1E8-4A72-91DE-F7027D370543}.Release|Any CPU.Build.0 = Release|Any CPU
{57C9AB55-EA91-4F0E-B9C3-C9D9C1BB2FFE}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{57C9AB55-EA91-4F0E-B9C3-C9D9C1BB2FFE}.Debug|Any CPU.Build.0 = Debug|Any CPU
{57C9AB55-EA91-4F0E-B9C3-C9D9C1BB2FFE}.Release|Any CPU.ActiveCfg = Release|Any CPU
{57C9AB55-EA91-4F0E-B9C3-C9D9C1BB2FFE}.Release|Any CPU.Build.0 = Release|Any CPU
EndGlobalSection
EndGlobal
Light.Xunit-1.0.0/Code/Light.Xunit.sln.DotSettings 0000664 0000000 0000000 00000025142 14344615317 0021714 0 ustar 00root root 0000000 0000000
True
SUGGESTION
True
Built-in: Full Cleanup
Built-in: Full Cleanup
False
Required
Required
Required
ExpressionBody
ExpressionBody
ExpressionBody
TargetTyped
False
True
True
True
True
True
True
True
True
True
True
True
TOGETHER_SAME_LINE
NO_INDENT
False
False
False
False
False
False
False
1
3
COMPACT
True
True
True
True
NEVER
ALWAYS
ALWAYS
ALWAYS
NEVER
False
ALWAYS
ALWAYS
NEVER
True
True
False
CHOP_IF_LONG
CHOP_IF_LONG
False
True
False
CHOP_IF_LONG
CHOP_IF_LONG
CHOP_IF_LONG
150
CHOP_ALWAYS
CHOP_IF_LONG
CHOP_ALWAYS
CHOP_IF_LONG
RemoveIndent
RemoveIndent
False
ByFirstAttr
150
False
False
True
False
True
True
True
True
True
True Light.Xunit-1.0.0/Code/Light.Xunit/ 0000775 0000000 0000000 00000000000 14344615317 0016724 5 ustar 00root root 0000000 0000000 Light.Xunit-1.0.0/Code/Light.Xunit/AssemblyInfos.cs 0000664 0000000 0000000 00000000165 14344615317 0022033 0 ustar 00root root 0000000 0000000 namespace Light.Xunit;
internal static class AssemblyInfos
{
public const string AssemblyName = "Light.Xunit";
} Light.Xunit-1.0.0/Code/Light.Xunit/CreateNuGetPackage.cmd 0000664 0000000 0000000 00000000133 14344615317 0023030 0 ustar 00root root 0000000 0000000 dotnet pack ./Light.Xunit.csproj --configuration Release /p:ContinuousIntegrationBuild=true Light.Xunit-1.0.0/Code/Light.Xunit/Light.Xunit.csproj 0000664 0000000 0000000 00000005430 14344615317 0022325 0 ustar 00root root 0000000 0000000
netstandard2.0
Kenny Pflug
Kenny Pflug
Copyright © Kenny Pflug 2022
Provides useful extensions for xunit.net test projects.
xunit;unit;automated;testing;testsettings;configuration;test;order
1.0.0
enable
11.0
true
light-logo.png
true
true
https://github.com/feO2x/Light.Xunit
https://github.com/feO2x/Light.Xunit.git
git
true
true
snupkg
true
MIT
readme.md
Light.Xunit
--------------------------------
- initial release 🥳🍻🎈
- use the TestConfiguration to configure your automated tests based on Microsoft.Extensions.Configuration
- use ShouldBeWrittenTo to easily log exceptions and strings
- use TestOrderer to easily run tests in a class in a specific order
- read all docs at https://github.com/feO2x/Light.Xunit
Light.Xunit-1.0.0/Code/Light.Xunit/Light.Xunit.props 0000664 0000000 0000000 00000001140 14344615317 0022162 0 ustar 00root root 0000000 0000000
PreserveNewest
PreserveNewest
PreserveNewest
Light.Xunit-1.0.0/Code/Light.Xunit/TestConfiguration.cs 0000664 0000000 0000000 00000002006 14344615317 0022720 0 ustar 00root root 0000000 0000000 using System;
using Light.GuardClauses;
namespace Light.Xunit;
internal sealed record TestConfiguration
{
public bool IsInBuildServerMode
{
get
{
if (IsInBuildServerModeEnvironmentVariableName.IsNullOrWhiteSpace())
return false;
var environmentVariable = Environment.GetEnvironmentVariable(IsInBuildServerModeEnvironmentVariableName);
if (environmentVariable is null)
return false;
var trimmedVariable = environmentVariable.Trim();
return trimmedVariable.Equals("true", StringComparisonType.OrdinalIgnoreCase) ||
trimmedVariable.Equals("1", StringComparison.Ordinal);
}
}
public string IsInBuildServerModeEnvironmentVariableName { get; set; } = string.Empty;
public bool LoadEnvironmentVariables { get; set; }
public string EnvironmentVariablesPrefix { get; set; } = string.Empty;
public bool LoadDevelopmentSettingsFileInBuildServerMode { get; set; } = false;
} Light.Xunit-1.0.0/Code/Light.Xunit/TestExtensions.cs 0000664 0000000 0000000 00000002104 14344615317 0022247 0 ustar 00root root 0000000 0000000 using System;
using Light.GuardClauses;
using Xunit.Abstractions;
namespace Light.Xunit;
///
/// Provides extensions for test scenarios.
///
public static class TestExtensions
{
///
/// Writes the specified message to the test output helper.
///
/// Thrown when or is null.
public static void ShouldBeWrittenTo(this string message, ITestOutputHelper output) =>
output.MustNotBeNull(nameof(output)).WriteLine(message);
///
/// Writes the specified exception to the test output helper.
///
/// Thrown when or is null.
public static void ShouldBeWrittenTo(this Exception exception, ITestOutputHelper output)
{
exception.MustNotBeNull(nameof(exception));
output.MustNotBeNull(nameof(output))
.WriteLine(exception.ToString());
}
} Light.Xunit-1.0.0/Code/Light.Xunit/TestOrderAttribute.cs 0000664 0000000 0000000 00000002076 14344615317 0023057 0 ustar 00root root 0000000 0000000 using System;
using Xunit.Sdk;
namespace Light.Xunit;
///
/// Use this attribute to specify the execution order of xunit tests within a test class.
///
[TraitDiscoverer(TestOrderDiscoverer.TypeName, TestOrderDiscoverer.AssemblyName)]
[AttributeUsage(AttributeTargets.Method)]
public sealed class TestOrderAttribute : Attribute, ITraitAttribute
{
///
/// The name of the trait that identifies test order values. The value is "TestOrder".
///
public const string TraitName = "TestOrder";
///
/// Initializes a new instance of with the specified order value.
///
///
/// The ordinal value that indicates the order of the test. It is recommended to start with 1
/// and subsequently increase the order of each test.
///
public TestOrderAttribute(int order) => Order = order;
///
/// Gets the ordinal value that indicates the order of the test.
///
public int Order { get; }
} Light.Xunit-1.0.0/Code/Light.Xunit/TestOrderDiscoverer.cs 0000664 0000000 0000000 00000004323 14344615317 0023216 0 ustar 00root root 0000000 0000000 using System.Collections.Generic;
using Xunit.Abstractions;
using Xunit.Sdk;
namespace Light.Xunit;
///
/// Represents a trait discoverer that is optimized for handling the .
///
// ReSharper disable once ClassNeverInstantiated.Global -- instantiated by Xunit
public sealed class TestOrderDiscoverer : TraitDiscoverer
{
///
/// Gets the type name of this trait discoverer.
///
public const string TypeName = AssemblyInfos.AssemblyName + "." + nameof(TestOrderDiscoverer);
///
/// Gets the assembly name where this type resides in.
///
public const string AssemblyName = AssemblyInfos.AssemblyName;
///
/// Checks if the specified attribute is a . If not, then the base class implementation
/// will handle the attribute. Otherwise, the order of the attribute is returned with the key "Test Order".
///
public override IEnumerable> GetTraits(IAttributeInfo traitAttribute)
{
var order = traitAttribute.GetNamedArgument(nameof(TestOrderAttribute.Order));
var orderAsText = ConvertOrderNumberToString(order);
return new[] { new KeyValuePair(TestOrderAttribute.TraitName, orderAsText) };
}
private static string ConvertOrderNumberToString(int order)
{
switch (order)
{
case 0: return "0";
case 1: return "1";
case 2: return "2";
case 3: return "3";
case 4: return "4";
case 5: return "5";
case 6: return "6";
case 7: return "7";
case 8: return "8";
case 9: return "9";
case 10: return "10";
case 11: return "11";
case 12: return "12";
case 13: return "13";
case 14: return "14";
case 15: return "15";
case 16: return "16";
case 17: return "17";
case 18: return "18";
case 19: return "19";
case 20: return "20";
default:
return order.ToString();
}
}
} Light.Xunit-1.0.0/Code/Light.Xunit/TestOrderer.cs 0000664 0000000 0000000 00000005415 14344615317 0021522 0 ustar 00root root 0000000 0000000 using System.Collections.Generic;
using System.Linq;
using Light.GuardClauses;
using Xunit.Abstractions;
using Xunit.Sdk;
namespace Light.Xunit;
///
/// Represents a test case orderer that orders test cases according to their code line number by default.
/// Additionally, tests can be explicitly ordered by using the .
///
// ReSharper disable once ClassNeverInstantiated.Global -- instantiated by Xunit
public sealed class TestOrderer : ITestCaseOrderer
{
///
/// Gets the type name of this test case orderer.
///
public const string TypeName = AssemblyInfos.AssemblyName + "." + nameof(TestOrderer);
///
/// Gets the assembly name where this test case orderer is located in.
///
public const string AssemblyName = AssemblyInfos.AssemblyName;
///
/// Tries to order the test cases according to the "TestOrder" trait. If that is not possible,
/// the tests are ordered by their code line number.
///
public IEnumerable OrderTestCases(IEnumerable testCases) where TTestCase : ITestCase
{
var list = testCases.MustNotBeNull(nameof(testCases)).ToList();
if (CheckIfTestOrderTraitIsPresent(list))
return OrderByTrait(list);
if (CheckIfSourceInformationIsPresent(list))
return OrderByLineNumber(list);
return list;
}
private static bool CheckIfTestOrderTraitIsPresent(List list) where TTestCase : ITestCase
{
for (var i = 0; i < list.Count; i++)
{
if (list[i].Traits.ContainsKey(TestOrderAttribute.TraitName))
return true;
}
return false;
}
private static IEnumerable OrderByTrait(List list) where TTestCase : ITestCase =>
list.OrderBy(testCase =>
{
if (testCase.Traits.TryGetValue(TestOrderAttribute.TraitName, out var values) &&
values.Count > 0 &&
int.TryParse(values[0], out var testOrder))
{
return testOrder;
}
return int.MaxValue;
});
private static bool CheckIfSourceInformationIsPresent(List list) where TTestCase : ITestCase
{
for (var i = 0; i < list.Count; i++)
{
var testCase = list[i];
if (testCase.SourceInformation?.LineNumber == null)
return false;
}
return true;
}
private static IEnumerable OrderByLineNumber(List list) where TTestCase : ITestCase =>
list.OrderBy(testCase => testCase.SourceInformation!.LineNumber!.Value);
} Light.Xunit-1.0.0/Code/Light.Xunit/TestSettings.cs 0000664 0000000 0000000 00000031205 14344615317 0021714 0 ustar 00root root 0000000 0000000 using System;
using Light.GuardClauses;
using Microsoft.Extensions.Configuration;
namespace Light.Xunit;
///
///
/// Provides an ambient context for test settings. This class loads up to three
/// optional configuration files ("testsettings.json", "testsettings.Development.json",
/// and "testsettings.Build.json") as well as environment variables and
/// provides the property to access them
/// (if you don't want to use the default settings, you can omit the
/// property and instead call .
/// Light.Xunit will automatically copy testsettings.json, testsettings.Development.json,
/// and testsettings.Build.json to the output directory if they are present right next
/// to your csproj file of your test project.
///
///
/// All of the sources are optional and can be configured
/// by supplying a dedicated section in at least one
/// of the JSON files:
///
///
/// {
/// "testConfiguration": {
/// "isInBuildServerModeEnvironmentVariableName": "CI",
/// "loadEnvironmentVariables": true,
/// "environmentVariablesPrefix": "Test_",
/// "loadDevelopmentSettingsFileInBuildServerMode": false
/// }
/// }
///
///
/// The three files are treated in the following way:
///
///
/// -
/// testsettings.json
///
/// This is the standard file which contains all configuration sections and values. It allows developers
/// to easily discover the available settings. All integration tests (i.e. tests that require a third-party
/// system like a database, web service, etc.) should be deactivated by default to allow simply cloning
/// of the repo on a dev machine and successfully running all tests (skipping integration tests).
///
///
/// -
/// testsettings.Development.json
///
/// This file allows developers to set specific settings to different values on his or her dev machine. It is
/// not tracked by the repository. By default, this file is not loaded when Build Server Mode is active,
/// unless you set "loadDevelopmentSettingsFileInBuildServerMode" to true.
///
///
/// -
/// testsettings.Build.json
///
/// This file should be used on build servers. It is only loaded when the
/// method determines that it runs in Build Server mode.
/// This file can be checked into the repository for non-sensitive settings.
///
///
///
///
public static class TestSettings
{
private static readonly Lazy LazyConfiguration = new (() => LoadConfiguration());
///
///
/// Gets the default configuration that was loaded from the optional files "testsettings.json",
/// "testsettings.Development.json", and "testsettings.Build.json", as well as environment variables.
/// Please see the XML comment on on details about the default configuration.
///
///
/// The field behind this property is lazily loaded using Lazy<T> with default settings.
/// You can also load an instance by yourself if you call the
/// method.
///
///
public static IConfiguration Configuration => LazyConfiguration.Value;
///
///
/// Loads an object from three optional files testsettings.json, testsettings.Build.json,
/// and testsettings.Development.json, and from environment variables. All of the sources are optional and
/// can be configured either via the parameters of this method, or by supplying a dedicated section in at least one
/// of the JSON files:
///
///
/// {
/// "testConfiguration": {
/// "isInBuildServerModeEnvironmentVariableName": "CI",
/// "loadEnvironmentVariables": true,
/// "environmentVariablesPrefix": "Test_",
/// "loadDevelopmentSettingsFileInBuildServerMode": false
/// }
/// }
///
///
/// Please refer to the corresponding parameters with the same name to check their meaning.
///
///
/// The three files are treated in the following way:
///
///
/// -
/// testsettings.json
///
/// This is the standard file which contains all configuration sections and values. It allows developers
/// to easily discover the available settings. All integration tests (i.e. tests that require a third-party
/// system like a database, web service, etc.) should be deactivated by default to allow simply cloning
/// of the repo on a dev machine and successfully running all tests (skipping integration tests).
///
///
/// -
/// testsettings.Development.json
///
/// This file allows developers to set specific settings to different values on his or her dev machine. It is
/// not tracked by the repository. By default, this file is not loaded when Build Server Mode is active,
/// unless you set to true.
///
///
/// -
/// testsettings.Build.json
///
/// This file should be used on build servers. It is only loaded when the
/// method determines that it runs in Build Server mode.
/// This file can be checked into the repository for non-sensitive settings.
///
///
///
///
///
/// The name of the default test settings file (testsettings.json).
///
/// The name of the local development file (testsettings.Development.json).
/// The name of the build server file (testsettings.Build.json).
///
/// The value indicating whether Build Server mode is turned on. If this value is set to null,
/// the value will be determined via .
///
///
/// The name of the environment variable that indicates whether Build Server mode is active.
/// The value of this environment variable (not the parameter) must be either "True" or "1" for Build Server mode to
/// be activated.
///
///
/// The value indicating whether the returned object will also contain
/// values from environment variables. If this value is set to null, this method will try to obtain the
/// value from one of the JSON files.
///
///
/// The prefix that environment variable names must start with. The prefix will be removed from the environment variable is
/// added to the instance.
///
///
/// The value indicating whether the development settings file will also be loaded in Build Server mode. By default,
/// only the testsettings.json and testsettings.Build.json files are loaded in this mode. If this value is set
/// to null, this method will try to retrieve it from one of the JSON files.
///
///
/// Thrown when either , or ,
/// or are null.
///
///
/// Thrown when either , or ,
/// or are empty or contain only white space.
///
public static IConfigurationRoot LoadConfiguration(string testsettingsFileName = "testsettings.json",
string developmentFileName = "testsettings.Development.json",
string buildServerFileName = "testsettings.Build.json",
bool? isInBuildServerMode = null,
string isInBuildServerModeEnvironmentVariableName = "",
bool? loadEnvironmentVariables = null,
string environmentVariablesPrefix = "",
bool? loadDevelopmentSettingsFileInBuildServerMode = null)
{
testsettingsFileName.MustNotBeNullOrWhiteSpace();
developmentFileName.MustNotBeNullOrWhiteSpace();
buildServerFileName.MustNotBeNullOrWhiteSpace();
var firstConfiguration = new ConfigurationBuilder().AddJsonFile(testsettingsFileName, true)
.AddJsonFile(developmentFileName, true)
.AddJsonFile(buildServerFileName, true)
.Build();
var testConfiguration = new TestConfiguration();
firstConfiguration.GetSection("testConfiguration")
.Bind(testConfiguration);
if (loadEnvironmentVariables == true)
testConfiguration.LoadEnvironmentVariables = true;
if (!environmentVariablesPrefix.IsNullOrWhiteSpace())
testConfiguration.EnvironmentVariablesPrefix = environmentVariablesPrefix;
if (!isInBuildServerModeEnvironmentVariableName.IsNullOrWhiteSpace())
testConfiguration.IsInBuildServerModeEnvironmentVariableName = isInBuildServerModeEnvironmentVariableName;
return new ConfigurationBuilder().AddJsonFile(testsettingsFileName, true)
.AddFurtherConfigurationFiles(testConfiguration,
isInBuildServerMode,
loadDevelopmentSettingsFileInBuildServerMode,
developmentFileName,
buildServerFileName)
.AddEnvironmentVariablesIfNecessary(testConfiguration)
.Build();
}
private static IConfigurationBuilder AddFurtherConfigurationFiles(this IConfigurationBuilder configurationBuilder,
TestConfiguration testConfiguration,
bool? isBuildServerMode,
bool? loadDevelopmentSettingsFileInBuildServerMode,
string developmentFileName,
string buildServerFileName)
{
if (isBuildServerMode == true || testConfiguration.IsInBuildServerMode)
{
configurationBuilder.AddJsonFile(buildServerFileName, true);
if (loadDevelopmentSettingsFileInBuildServerMode == true || testConfiguration.LoadDevelopmentSettingsFileInBuildServerMode)
configurationBuilder.AddJsonFile(developmentFileName, true);
return configurationBuilder;
}
configurationBuilder.AddJsonFile(developmentFileName, true);
return configurationBuilder;
}
private static IConfigurationBuilder AddEnvironmentVariablesIfNecessary(this IConfigurationBuilder configurationBuilder,
TestConfiguration testConfiguration)
{
if (!testConfiguration.LoadEnvironmentVariables)
return configurationBuilder;
return testConfiguration.EnvironmentVariablesPrefix.IsNullOrWhiteSpace() ?
configurationBuilder.AddEnvironmentVariables() :
configurationBuilder.AddEnvironmentVariables(testConfiguration.EnvironmentVariablesPrefix);
}
} Light.Xunit-1.0.0/LICENSE 0000664 0000000 0000000 00000002054 14344615317 0014703 0 ustar 00root root 0000000 0000000 MIT License
Copyright (c) 2022 Kenny Pflug
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
Light.Xunit-1.0.0/light-logo.png 0000664 0000000 0000000 00000010364 14344615317 0016454 0 ustar 00root root 0000000 0000000 PNG
IHDR L\ pHYs od IDATx] x罗&l$(&*BY+RbmUnXZAPXPE}W$o7[ϝ"yyܙ|{3;gsν תU+Q"+
gd3"Ѯh{YTfIA+TdW\ tPUz3_@ `ޥsV>,ֹ|vibiӇ圮"V#UWɁqmn
Rkf+˦ ,Y tQV/LCx` ~jwa6:Qudb M^dtxq59K^VYb @>8:i O}'mY,n[N9C>X1$^9
SppC`Ҷ%
0! 38rd'pҐWY6nIxmT5A~{
,$
=EO؈ҋȿ\xpCS Eo-ܛ_&0Iy[t4cdOOgh'& K5^~
WZ~pf9p?a*jR6[(+@B
&VcQ9| /4ckօ. ˀ$6pp}a?B @ >t)CySFW# /ow@V~[c { &^ rT0 Ѽ 5ۑjM .ٺ# @ƆNTѩ7
/ !uz .Z((sa3 P d6 [TX G8v#!`Q̖Ve$ɉ (fI' `( CRw_DӐ|"6! 'J;^{?]?_}0%yA UA*!th 4@Q / oC[^@ 'lV]qOEG};ZApBUpd/W_c.@⽆ݥV wp@nWFoW9gџ IpR5OL ]\FnN B$@s5yI>D}R*l |Ѧr*~r\/: ;Cw,+w6dY+qiB2/ٔFq7u=@g>TɀHtġy Vada&
34yLL X&nN
~_T; t?}@SD=FZ SMdn1I/I{1z,HY~VKn ?ss5vK>=> v(0Rf$ -1ϲ0A] I%V F. X[y[V0~Ӿ];7,h.Lq56`q ^lO,x<~z9\HdyPY ݍ?7Hn"g6 : [5v 0iSf> ܕd嶉^*=գ
ؗ4}͂·xqo/8 kZLNMG)J@v*uxMq@TҤ
j\|I&dx!vՃϦf09 2x$ r>zS" &P C2X0Jv 6iܤ/l'phof2:b qUM͝Bͫu a:ƛw-8oٴ= դ%KDqv
Ȏ=47ЀwaFcs&,`7
[c(i8 <7$C[%|ne)xf%BMbuCo
l9vIg_ "c_H˙l
'5o|oU+g!u[?!)pk in6irz2vcI a-[-mꯚ=7ͩjFlOs `~^ @ڬ,ySǤ5w1 +FI"5);f RxtU,Entw垓g$|QޖC-9`tL5 }[KR**)N="[cYk ?;}X} 9$mn6[qћ~ .4)((oUyƿˑZd!
еcҗe/nuAK488@59ȴ WGs /q75 RKd< c܌AUO?~(ft$K?d(fgP3oC+xj`: .o;CZ gsn~b-.x%t}{#)g #)u|v|,"mZdծٮ,}G0[_'I@Pq-*+
p5VEc*6~ 4_WX \*BG!5|+| X30%*{8ktCjq ˙km !)#+ !"`=?2$`ghs "$0nV17+;} b , Em3i2jeV 6ES-~>I^Za8F-Kv v0sT+c-`HQǦ9}3v=֝β eo8ZDvP`
BY䶗n&.ḿ`] z
'(/!b%!2)XWABpkaլM=&aKgd G0yVZA>#+
gd3W1] IENDB` Light.Xunit-1.0.0/readme.md 0000664 0000000 0000000 00000024403 14344615317 0015457 0 ustar 00root root 0000000 0000000 # Light.Xunit
*Provides useful extensions for xunit.net test projects.*
[](https://github.com/feO2x/Light.Xunit/blob/main/LICENSE)
[](https://www.nuget.org/packages/Light.Xunit/)
# How to Install
Light.Xunit is compiled against [.NET Standard 2.0](https://docs.microsoft.com/en-us/dotnet/standard/net-standard) and thus supports all major plattforms like .NET, .NET Framework 4.6.1 or newer, Mono, Xamarin, UWP, or Unity.
Light.Xunit is available as a [NuGet package](https://www.nuget.org/packages/Light.Xunit/) and can be installed via:
- **Package Reference in csproj**: ``
- **dotnet CLI**: `dotnet add package Light.Xunit`
- **Visual Studio Package Manager Console**: `Install-Package Light.Xunit`
# What does Light.Xunit offer you?
## testsettings.json
Light.Xunit comes with a class called `TestSettings` that allows you to customize tests via configuration files. It loads up to three optional configuration files ("testsettings.json", "testsettings.Development.json", and "testsettings.Build.json") by default and provides the `Configuration` property to access an `IConfiguration` instance that holds the loaded configuration. You can rely on all the goodness of [Microsoft.Extensions.Configuration](https://learn.microsoft.com/en-us/dotnet/core/extensions/configuration) that you know from ASP.NET Core apps.
This is especially useful for integration tests where you target different databases on different test systems (e.g. individual dev machines vs. build server). Together with packages like [Xunit.SkippableFact](https://www.nuget.org/packages/Xunit.SkippableFact/), you can easily customize your integration tests.
A common use case might look like this:
In testsettings.json:
```jsonc
{
// This file should be checked in your version control system and provide default settings.
// Developers can individually set values in testsettings.Development.json.
"database": {
"areIntegrationTestsEnabled": false,
"connectionString": "Server=(localdb)\\MsSqlLocalDb;Database=MyDatabase;Integrated Security=True"
}
}
```
In testsettings.Development.json:
```jsonc
{
// Developers can set individual values for their dev machine in this file
// (we recommend you ignore this file in your version control system).
"database": {
"areIntegrationTestsEnabled": true,
"connectionString": "Server=MyDevInstance;Database=MyDatabase;Integrated Security=True"
}
}
```
Your test code:
```csharp
using Light.Xunit;
using Xunit;
namespace MyTestProject;
public class DatabaseIntegrationTests
{
[SkippableFact] // This attribute is in Xunit.SkippableFact
public async Task ConnectToDatabase()
{
SkipTestIfNecessary();
var connectionString = GetConnectionString();
await using var sqlConnection = new SqlConnection(connectionString);
await sqlConnection.OpenAsync();
// Test something using the sqlConnection
}
private static void SkipTestIfNecessary() =>
Skip.IfNot(TestSettings.Configuration.GetValue("database:areIntegrationTestsEnabled"));
private static string GetConnectionString() =>
TestSettings.Configuration["database:connectionString"];
}
```
General recommendations for test settings:
- all integration tests that require a third-party system to be in place should be skippable and turned off by default.
- your version control system should ignore `testsettings.*.json` files. This way, each developer can create this file locally to provide custom settings according to his or her environment
- build servers should provide testsettings.Build.json to customize the settings for test runs in automated builds.
The three testsettings files will be automatically copied to the output directory when you place them next to the csproj file of your test project. When loading these files, Light.Xunit will determine if it should run in Build Server mode. In Build Server mode, the `IConfiguration` instance will only contain testsettings.json, testsettings.Build.json, and environment variables. In non Build Server mode, testsettings.Build.json is replaced with testsettings.Development.json. Light.Xunit determines this by trying to load all three files, determining if Build Server mode is active, and then loading the configuration again with only the files you need (the reason for this complex approach is that there is no dedicated Composition Root in xunit that we could hook into).
You usually want to use an environment variable that is defined on your build server, but not on your dev machines (e.g. GitLab defines an environment variable called "CI" which is set to "True") to determine whether Build Server mode is active. You can customize this behavior by placing a dedicated section called "testConfiguration" in one of your JSON files (typically testsettings.json). This section is structured like this:
```jsonc
{
"testConfiguration": {
// The name of the environment variable that determines whether Build Server mode is active.
// The value of this environment variable must be either "True" or "1" so that
// Light.Xunit actives this mode.
"isInBuildServerModeEnvironmentVariableName": "CI",
// The value indicating whether environment variables should be loaded, too
"loadEnvironmentVariables": true,
// If you set this value, only the environment variables with this prefix will be loaded.
// The prefix will be stripped from environment variable name when it is added to
// the IConfiguration instance (default behavior of Microsoft.Extensions.Configuration).
"environmentVariablesPrefix": "Test_",
// The value indicating whether the testsettings.Development.json file should also
// be loaded in Build Server mode. Usually, you only want to set this value to true
// when you need to replicate a certain behavior of the build server on a local
// dev machine.
"loadDevelopmentSettingsFileInBuildServerMode": false
}
}
```
If you want even more control, you can use the `TestSettings.LoadConfiguration` method instead of accessing the default `TestSettings.Configuration` instance. Check its XML comments for detailed instructions.
## Run tests in a specific order
By default, xunit runs your tests in a non-deterministic / random order, even within a single test class. This is a good default behavior, because your tests should be independent from each other. However, especially when you write integration tests for a third-party system (e.g. a database or a web service) where you also need to manage its state, you might want to run your tests in a specific order. You can use Light.Xunit's `TestOrderer` for these circumstances - it needs to be supplied to xunit's `TestCaseOrdererAttribute`:
```csharp
using Light.Xunit;
using Xunit;
namespace TestProject;
// The following attribute enables TestOrderer on this test class
[TestCaseOrderer(TestOrderer.TypeName, TestOrderer.AssemblyName)]
public class TestClass
{
private static int Value { get; set; } = 1;
[Fact]
public void Test1()
{
Assert.Equal(1, Value);
Value = 33;
}
[Fact]
public void Test2()
{
Assert.Equal(33, Value);
Value = 7;
}
[Fact]
public void Test3()
{
Assert.Equal(7, Value);
}
}
```
By simply applying the `TestOrderer` to the test class, the containing tests will be ordered according to their source code line number. Thus if you simply want to run the tests in the same order as they occur in your test class, then you are done. However, if you want to specify the order of the tests on your own, you can do that with the `TestOrderAttribute`:
```csharp
using Light.Xunit;
using Xunit;
namespace TestProject;
// The following attribute enables TestOrderer on this test class
[TestCaseOrderer(TestOrderer.TypeName, TestOrderer.AssemblyName)]
public class TestClass
{
private static int Value { get; set; } = 1;
[Fact]
[TestOrder(3)]
public void Test3()
{
Assert.Equal(7, Value);
}
[Fact]
[TestOrder(1)]
public void Test1()
{
Assert.Equal(1, Value);
Value = 33;
}
[Fact]
[TestOrder(2)]
public void Test2()
{
Assert.Equal(33, Value);
Value = 7;
}
}
```
Please keep in mind: when you apply the `TestOrderAttribute`, you need to apply it to all tests of a class - otherwise the `TestOrderer` will use the line numbers to order your tests. And no matter whether you use the `TestOrderAttribute` or not, you must decorate the corresponding class with `[TestCaseOrderer(TestOrderer.TypeName, TestOrderer.AssemblyName)]`, otherwise the default ordering of xunit will be applied.
Furthermore, if you access the same third-party system in several test classes, you should generally consider running your test sequentially. Dependending on your data access layer, concurrent requests might lead to unexpected test outcome when two or more tests in different classes access the system concurrently. You can do that by placing the following lines of code into a new file in your xunit test project:
```csharp
using Xunit;
[assembly:CollectionBehavior(DisableTestParallelization = true)]
```
With this in place, all tests will be executed sequentially.
## Write strings and exceptions to ITestOutputHelper with ShouldBeWrittenTo
Light.Xunit contains two extension methods that allow you to easily write `string` or `Exception` instances to an `ITestOutputHelper`. This is especially useful in combination with [FluentAssertions](https://fluentassertions.com/).
```csharp
public sealed class OrderProcessorTests
{
public TestClass(ITestOutputHelper output) => Output = output;
private ITestOutputHelper Output { get; }
[Fact]
public void CancelledOrdersShouldNotBeProcessed()
{
Action act => () => OrderProcessor.ProcessOrders(new Order { Id = 1, State = State.Cancelled } );
act.Should().Throw()
.Which.ShouldBeWrittenTo(Output); // as an alternative: .And.Message.ShouldBeWrittenTo(Output)
}
}
```