Skip to content

[Test Improver] test: add unit tests for LoggingManager.BuildAsync and ExtensionValidationHelper.ValidateUniqueExtension #8126

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
Evangelink wants to merge 6 commits into
base: main
Choose a base branch
from
Open

[Test Improver] test: add unit tests for LoggingManager.BuildAsync and ExtensionValidationHelper.ValidateUniqueExtension #8126

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
6 commits
Select commit Hold shift + click to select a range
4fa32ae
test: add unit tests for LoggingManager.BuildAsync and ExtensionValid…
github-actions[bot] May 9, 2026
064f249
test: address review feedback in logging and extension tests
Copilot May 11, 2026
27ca38f
test: dispose logger factory instances in logging tests
Copilot May 11, 2026
99e7312
Merge origin/main and resolve LoggingManagerTests conflict
Copilot May 11, 2026
5c9c12b
Merge latest main and resolve ExtensionValidationHelperTests conflict
Copilot May 11, 2026
9690f8c
Fix CS8625 in DesktopTestSourceHostTests
Copilot May 11, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
4 changes: 2 additions & 2 deletions ...UnitTests/MSTestAdapter.PlatformServices.UnitTests/Services/DesktopTestSourceHostTests.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -104,7 +104,7 @@ public void SetupHostShouldSetChildDomainsAppBaseToTestSourceLocation()
_ = new DummyClass();

string location = typeof(TestSourceHost).Assembly.Location;
Mock<TestSourceHost> sourceHost = new(location, null) { CallBase = true };
Mock<TestSourceHost> sourceHost = new(location, (IRunSettings?)null) { CallBase = true };

try
{
Expand Down Expand Up @@ -161,7 +161,7 @@ public void SetupHostShouldSetResolutionsPaths()
DummyClass dummyClass = new();

string location = typeof(TestSourceHost).Assembly.Location;
Mock<TestSourceHost> sourceHost = new(location, null) { CallBase = true };
Mock<TestSourceHost> sourceHost = new(location, (IRunSettings?)null) { CallBase = true };

try
{
Expand Down
214 changes: 113 additions & 101 deletions .../UnitTests/Microsoft.Testing.Platform.UnitTests/Helpers/ExtensionValidationHelperTests.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,198 +1,210 @@
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information.

using Microsoft.Testing.Platform.Extensions;
using Microsoft.Testing.Platform.Helpers;
using Microsoft.Testing.Platform.UnitTests.Helpers;

namespace Microsoft.Testing.Platform.UnitTests;

[TestClass]
public sealed class ExtensionValidationHelperTests
{
// Generic overload: ValidateUniqueExtension<T>(IEnumerable<T>, IExtension, Func<T, IExtension>)
// ValidateUniqueExtension<T> overload (with extensionSelector)
[TestMethod]
public void ValidateUniqueExtension_WhenExistingExtensionsIsNull_ThrowsArgumentNullException()
public void ValidateUniqueExtension_WithSelector_NullExistingExtensions_ThrowsArgumentNullException()
{
IEnumerable<IExtension> existingExtensions = null!;
IExtension newExtension = CreateExtension("uid1");
IEnumerable<IExtension> nullExtensions = null!;
TestExtension newExtension = new();

Assert.ThrowsExactly<ArgumentNullException>(
() => existingExtensions.ValidateUniqueExtension(newExtension, x => x));
Assert.ThrowsExactly<ArgumentNullException>(() =>
nullExtensions.ValidateUniqueExtension(newExtension, x => x));
}

[TestMethod]
public void ValidateUniqueExtension_WhenNewExtensionIsNull_ThrowsArgumentNullException()
public void ValidateUniqueExtension_WithSelector_NullNewExtension_ThrowsArgumentNullException()
{
IExtension[] existingExtensions = [];
IExtension newExtension = null!;
List<IExtension> existing = [];

Assert.ThrowsExactly<ArgumentNullException>(
() => existingExtensions.ValidateUniqueExtension(newExtension, x => x));
Assert.ThrowsExactly<ArgumentNullException>(() =>
existing.ValidateUniqueExtension(null!, x => x));
}

[TestMethod]
public void ValidateUniqueExtension_WhenExtensionSelectorIsNull_ThrowsArgumentNullException()
public void ValidateUniqueExtension_WithSelector_NullExtensionSelector_ThrowsArgumentNullException()
{
IExtension[] existingExtensions = [];
IExtension newExtension = CreateExtension("uid1");
List<IExtension> existing = [];
TestExtension newExtension = new();

Assert.ThrowsExactly<ArgumentNullException>(
() => existingExtensions.ValidateUniqueExtension<IExtension>(newExtension, null!));
Assert.ThrowsExactly<ArgumentNullException>(() =>
existing.ValidateUniqueExtension<IExtension>(newExtension, null!));
}

[TestMethod]
public void ValidateUniqueExtension_WhenCollectionIsEmpty_DoesNotThrow()
public void ValidateUniqueExtension_WithSelector_EmptyExistingCollection_DoesNotThrow()
{
IExtension[] existingExtensions = [];
IExtension newExtension = CreateExtension("uid1");
List<IExtension> existing = [];
TestExtension newExtension = new();

existingExtensions.ValidateUniqueExtension(newExtension, x => x);
existing.ValidateUniqueExtension(newExtension, x => x);
}

[TestMethod]
public void ValidateUniqueExtension_WhenNoDuplicateUid_DoesNotThrow()
public void ValidateUniqueExtension_WithSelector_NoDuplicateUid_DoesNotThrow()
{
IExtension[] existingExtensions = [CreateExtension("uid-A"), CreateExtension("uid-B")];
IExtension newExtension = CreateExtension("uid-C");
TestExtension existing1 = new() { UidOverride = "ext-1" };
TestExtension existing2 = new() { UidOverride = "ext-2" };
TestExtension newExtension = new() { UidOverride = "ext-3" };

existingExtensions.ValidateUniqueExtension(newExtension, x => x);
List<IExtension> existing = [existing1, existing2];

existing.ValidateUniqueExtension(newExtension, x => x);
}

[TestMethod]
public void ValidateUniqueExtension_WhenDuplicateUidExists_ErrorMessageContainsUid()
public void ValidateUniqueExtension_WithSelector_DuplicateUid_ThrowsInvalidOperationException()
Comment thread
Evangelink marked this conversation as resolved.
{
const string duplicateUid = "my-duplicate-uid";
IExtension[] existingExtensions = [CreateExtension(duplicateUid)];
IExtension newExtension = CreateExtension(duplicateUid);

InvalidOperationException ex = Assert.ThrowsExactly<InvalidOperationException>(
() => existingExtensions.ValidateUniqueExtension(newExtension, x => x));
TestExtension existingExtension = new() { UidOverride = "same-uid" };
TestExtension newExtension = new() { UidOverride = "same-uid" };
List<IExtension> existing = [existingExtension];

Assert.Contains(duplicateUid, ex.Message);
Assert.ThrowsExactly<InvalidOperationException>(() =>
existing.ValidateUniqueExtension(newExtension, x => x));
}

[TestMethod]
public void ValidateUniqueExtension_WhenDuplicateUidExists_ErrorMessageContainsTypeNames()
public void ValidateUniqueExtension_WithSelector_DuplicateUid_ErrorMessageContainsUid()
{
const string duplicateUid = "my-duplicate-uid";
FakeExtensionA existing = new(duplicateUid);
FakeExtensionB newExtension = new(duplicateUid);
TestExtension existingExtension = new() { UidOverride = "my-unique-uid" };
TestExtension newExtension = new() { UidOverride = "my-unique-uid" };
List<IExtension> existing = [existingExtension];

InvalidOperationException ex = Assert.ThrowsExactly<InvalidOperationException>(
() => ((IExtension[])[existing]).ValidateUniqueExtension(newExtension, x => x));
InvalidOperationException ex = Assert.ThrowsExactly<InvalidOperationException>(() =>
existing.ValidateUniqueExtension(newExtension, x => x));

Assert.Contains(typeof(FakeExtensionA).ToString(), ex.Message);
Assert.Contains(typeof(FakeExtensionB).ToString(), ex.Message);
Assert.Contains("my-unique-uid", ex.Message);
}

[TestMethod]
public void ValidateUniqueExtension_WhenMultipleDuplicatesExist_ErrorMessageContainsAllTypes()
public void ValidateUniqueExtension_WithSelector_MultipleDuplicates_ThrowsInvalidOperationException()
{
const string duplicateUid = "shared-uid";
FakeExtensionA existing1 = new(duplicateUid);
FakeExtensionB existing2 = new(duplicateUid);
FakeExtensionC newExtension = new(duplicateUid);
TestExtension existing1 = new() { UidOverride = "same-uid" };
TestExtension existing2 = new() { UidOverride = "same-uid" };
TestExtension newExtension = new() { UidOverride = "same-uid" };
List<IExtension> existing = [existing1, existing2];

InvalidOperationException ex = Assert.ThrowsExactly<InvalidOperationException>(
() => ((IExtension[])[existing1, existing2]).ValidateUniqueExtension(newExtension, x => x));
InvalidOperationException ex = Assert.ThrowsExactly<InvalidOperationException>(() =>
existing.ValidateUniqueExtension(newExtension, x => x));

Assert.Contains(typeof(FakeExtensionA).ToString(), ex.Message);
Assert.Contains(typeof(FakeExtensionB).ToString(), ex.Message);
Assert.Contains(typeof(FakeExtensionC).ToString(), ex.Message);
Assert.Contains("same-uid", ex.Message);
}

[TestMethod]
public void ValidateUniqueExtension_WithWrapperType_SelectsExtensionViaSelector()
public void ValidateUniqueExtension_WithSelector_UidIsCaseSensitive_DifferentCaseDoesNotThrow()
Comment thread
Evangelink marked this conversation as resolved.
Comment thread
Evangelink marked this conversation as resolved.
{
const string duplicateUid = "wrapper-uid";
ExtensionWrapper existing = new(CreateExtension(duplicateUid));
IExtension newExtension = CreateExtension(duplicateUid);
TestExtension existingExtension = new() { UidOverride = "uid-lowercase" };
TestExtension newExtension = new() { UidOverride = "UID-LOWERCASE" };
List<IExtension> existing = [existingExtension];

Assert.ThrowsExactly<InvalidOperationException>(
() => ((ExtensionWrapper[])[existing]).ValidateUniqueExtension(newExtension, w => w.Extension));
existing.ValidateUniqueExtension(newExtension, x => x);
}

[TestMethod]
public void ValidateUniqueExtension_WithWrapperType_WhenNoDuplicate_DoesNotThrow()
public void ValidateUniqueExtension_WithSelector_SelectorUsedToExtractExtension()
{
ExtensionWrapper existing = new(CreateExtension("uid-X"));
IExtension newExtension = CreateExtension("uid-Y");
Wrapper existing1 = new(new TestExtension { UidOverride = "ext-1" });
TestExtension newExtension = new() { UidOverride = "ext-1" };
List<Wrapper> wrappers = [existing1];

((ExtensionWrapper[])[existing]).ValidateUniqueExtension(newExtension, w => w.Extension);
Assert.ThrowsExactly<InvalidOperationException>(() =>
wrappers.ValidateUniqueExtension(newExtension, w => w.Extension));
}

[TestMethod]
public void ValidateUniqueExtension_WhenUidsDifferOnlyByCase_DoesNotThrow()
public void ValidateUniqueExtension_WithSelector_SelectorWithNonMatchingUid_DoesNotThrow()
{
IExtension[] existingExtensions = [CreateExtension("uid-A")];
IExtension newExtension = CreateExtension("uid-a");
Wrapper existing1 = new(new TestExtension { UidOverride = "ext-1" });
TestExtension newExtension = new() { UidOverride = "ext-2" };
List<Wrapper> wrappers = [existing1];

existingExtensions.ValidateUniqueExtension(newExtension, x => x);
wrappers.ValidateUniqueExtension(newExtension, w => w.Extension);
}

// Simple overload: ValidateUniqueExtension(IEnumerable<IExtension>, IExtension)
// ValidateUniqueExtension simple overload (IEnumerable<IExtension>)
[TestMethod]
public void ValidateUniqueExtension_SimpleOverload_WhenExistingExtensionsIsNull_ThrowsArgumentNullException()
public void ValidateUniqueExtension_SimpleOverload_NullExistingExtensions_ThrowsArgumentNullException()
{
IEnumerable<IExtension> existingExtensions = null!;
IExtension newExtension = CreateExtension("uid1");
IEnumerable<IExtension> nullExtensions = null!;
TestExtension newExtension = new();

Assert.ThrowsExactly<ArgumentNullException>(
() => existingExtensions.ValidateUniqueExtension(newExtension));
Assert.ThrowsExactly<ArgumentNullException>(() =>
nullExtensions.ValidateUniqueExtension(newExtension));
}

[TestMethod]
public void ValidateUniqueExtension_SimpleOverload_WhenNewExtensionIsNull_ThrowsArgumentNullException()
public void ValidateUniqueExtension_SimpleOverload_NullNewExtension_ThrowsArgumentNullException()
{
IExtension[] existingExtensions = [];
List<IExtension> existing = [];

Assert.ThrowsExactly<ArgumentNullException>(
() => existingExtensions.ValidateUniqueExtension(null!));
Assert.ThrowsExactly<ArgumentNullException>(() =>
existing.ValidateUniqueExtension(null!));
}

[TestMethod]
public void ValidateUniqueExtension_SimpleOverload_WhenNoDuplicate_DoesNotThrow()
public void ValidateUniqueExtension_SimpleOverload_EmptyExistingCollection_DoesNotThrow()
{
IExtension[] existingExtensions = [CreateExtension("uid-A"), CreateExtension("uid-B")];
IExtension newExtension = CreateExtension("uid-C");
List<IExtension> existing = [];
TestExtension newExtension = new();

existingExtensions.ValidateUniqueExtension(newExtension);
existing.ValidateUniqueExtension(newExtension);
}

[TestMethod]
public void ValidateUniqueExtension_SimpleOverload_WhenDuplicateUidExists_ThrowsInvalidOperationException()
public void ValidateUniqueExtension_SimpleOverload_NoDuplicateUid_DoesNotThrow()
{
const string duplicateUid = "my-duplicate-uid";
IExtension[] existingExtensions = [CreateExtension(duplicateUid)];
IExtension newExtension = CreateExtension(duplicateUid);
TestExtension existingExtension = new() { UidOverride = "ext-1" };
TestExtension newExtension = new() { UidOverride = "ext-2" };
List<IExtension> existing = [existingExtension];

InvalidOperationException ex = Assert.ThrowsExactly<InvalidOperationException>(
() => existingExtensions.ValidateUniqueExtension(newExtension));

Assert.Contains(duplicateUid, ex.Message);
existing.ValidateUniqueExtension(newExtension);
}

private static IExtension CreateExtension(string uid) => new FakeExtension(uid);

private abstract class FakeExtensionBase(string uid) : IExtension
[TestMethod]
public void ValidateUniqueExtension_SimpleOverload_DuplicateUid_ThrowsInvalidOperationException()
{
public string Uid => uid;
TestExtension existingExtension = new() { UidOverride = "same-uid" };
TestExtension newExtension = new() { UidOverride = "same-uid" };
List<IExtension> existing = [existingExtension];

public string Version => "1.0";
Assert.ThrowsExactly<InvalidOperationException>(() =>
existing.ValidateUniqueExtension(newExtension));
}

public string DisplayName => uid;
[TestMethod]
public void ValidateUniqueExtension_SimpleOverload_DuplicateUid_ErrorMessageContainsUid()
{
TestExtension existingExtension = new() { UidOverride = "duplicate-uid" };
TestExtension newExtension = new() { UidOverride = "duplicate-uid" };
List<IExtension> existing = [existingExtension];

public string Description => uid;
InvalidOperationException ex = Assert.ThrowsExactly<InvalidOperationException>(() =>
existing.ValidateUniqueExtension(newExtension));

public Task<bool> IsEnabledAsync() => Task.FromResult(true);
Assert.Contains("duplicate-uid", ex.Message);
}

private sealed class FakeExtension(string uid) : FakeExtensionBase(uid);

private sealed class FakeExtensionA(string uid) : FakeExtensionBase(uid);

private sealed class FakeExtensionB(string uid) : FakeExtensionBase(uid);
[TestMethod]
public void ValidateUniqueExtension_SimpleOverload_UidIsCaseSensitive_DifferentCaseDoesNotThrow()
{
TestExtension existingExtension = new() { UidOverride = "uid-lowercase" };
TestExtension newExtension = new() { UidOverride = "UID-LOWERCASE" };
List<IExtension> existing = [existingExtension];

private sealed class FakeExtensionC(string uid) : FakeExtensionBase(uid);
existing.ValidateUniqueExtension(newExtension);
}

private sealed record ExtensionWrapper(IExtension Extension);
private sealed class Wrapper(TestExtension extension)
{
public TestExtension Extension { get; } = extension;
}
}
4 changes: 3 additions & 1 deletion test/UnitTests/Microsoft.Testing.Platform.UnitTests/Helpers/TestExtension.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -5,7 +5,9 @@ namespace Microsoft.Testing.Platform.UnitTests.Helpers;

internal class TestExtension : IExtension
{
public string Uid => "Uid";
public string UidOverride { get; set; } = "Uid";

public string Uid => UidOverride;

public string Version => "Version";

Expand Down
Loading
Loading