diff --git a/src/Platform/Microsoft.Testing.Extensions.CtrfReport/Microsoft.Testing.Extensions.CtrfReport.csproj b/src/Platform/Microsoft.Testing.Extensions.CtrfReport/Microsoft.Testing.Extensions.CtrfReport.csproj
index 2170ff8714..a57c7e0410 100644
--- a/src/Platform/Microsoft.Testing.Extensions.CtrfReport/Microsoft.Testing.Extensions.CtrfReport.csproj
+++ b/src/Platform/Microsoft.Testing.Extensions.CtrfReport/Microsoft.Testing.Extensions.CtrfReport.csproj
@@ -65,6 +65,7 @@ $(CommonProductDescription)]]>
+
diff --git a/src/Platform/Microsoft.Testing.Extensions.HtmlReport/Microsoft.Testing.Extensions.HtmlReport.csproj b/src/Platform/Microsoft.Testing.Extensions.HtmlReport/Microsoft.Testing.Extensions.HtmlReport.csproj
index 743621f5e9..b72388b60f 100644
--- a/src/Platform/Microsoft.Testing.Extensions.HtmlReport/Microsoft.Testing.Extensions.HtmlReport.csproj
+++ b/src/Platform/Microsoft.Testing.Extensions.HtmlReport/Microsoft.Testing.Extensions.HtmlReport.csproj
@@ -67,6 +67,7 @@ $(CommonProductDescription)]]>
+
diff --git a/src/Platform/Microsoft.Testing.Extensions.JUnitReport/Microsoft.Testing.Extensions.JUnitReport.csproj b/src/Platform/Microsoft.Testing.Extensions.JUnitReport/Microsoft.Testing.Extensions.JUnitReport.csproj
index 83cd707b4e..b63bfeea80 100644
--- a/src/Platform/Microsoft.Testing.Extensions.JUnitReport/Microsoft.Testing.Extensions.JUnitReport.csproj
+++ b/src/Platform/Microsoft.Testing.Extensions.JUnitReport/Microsoft.Testing.Extensions.JUnitReport.csproj
@@ -65,6 +65,7 @@ $(CommonProductDescription)]]>
+
diff --git a/src/Platform/Microsoft.Testing.Extensions.PackagedApp/ActivatedAppTestHostHandle.cs b/src/Platform/Microsoft.Testing.Extensions.PackagedApp/ActivatedAppTestHostHandle.cs
index 4b3640b241..33c776e067 100644
--- a/src/Platform/Microsoft.Testing.Extensions.PackagedApp/ActivatedAppTestHostHandle.cs
+++ b/src/Platform/Microsoft.Testing.Extensions.PackagedApp/ActivatedAppTestHostHandle.cs
@@ -132,10 +132,6 @@ private static void RecoverScratchArtifacts(string? scratchDirectory, string? re
private void RecoverRetryArtifactManifest()
{
- const long MaxManifestBytes = 16L * 1024 * 1024;
- const int MaxManifestLineChars = 64 * 1024;
- const int MaxManifestRecords = 10_000;
-
if (_retryArtifactManifestPath is null
|| _retryArtifactManifestDestinationPath is null
|| _scratchDirectory is null)
@@ -146,27 +142,25 @@ private void RecoverRetryArtifactManifest()
try
{
if (!File.Exists(_retryArtifactManifestPath)
- || new FileInfo(_retryArtifactManifestPath).Length > MaxManifestBytes)
+ || new FileInfo(_retryArtifactManifestPath).Length > RetryArtifactManifest.MaxBytes)
{
return;
}
var recoveredLines = new List();
- foreach (string line in File.ReadLines(_retryArtifactManifestPath).Take(MaxManifestRecords))
+ foreach (string line in File.ReadLines(_retryArtifactManifestPath).Take(RetryArtifactManifest.MaxRecords))
{
- if (line.Length > MaxManifestLineChars)
+ if (line.Length > RetryArtifactManifest.MaxLineLength)
{
continue;
}
- int separatorIndex = line.IndexOf('\t');
- if (separatorIndex <= 0)
+ if (!RetryArtifactManifest.TrySplitEntry(line, out string? encodedPath, out string? encodedKindOrNullSentinel))
{
continue;
}
- string sourcePath = Path.GetFullPath(
- Encoding.UTF8.GetString(Convert.FromBase64String(line.Substring(0, separatorIndex))));
+ string sourcePath = Path.GetFullPath(RetryArtifactManifest.DecodePath(encodedPath));
string? recoveredPath = TryGetRecoveredArtifactPath(
sourcePath,
_resultsScratchDirectory,
@@ -180,8 +174,9 @@ private void RecoverRetryArtifactManifest()
continue;
}
- recoveredLines.Add(
- $"{Convert.ToBase64String(Encoding.UTF8.GetBytes(Path.GetFullPath(recoveredPath)))}{line[separatorIndex..]}");
+ recoveredLines.Add(RetryArtifactManifest.WriteEntryWithEncodedKind(
+ Path.GetFullPath(recoveredPath),
+ encodedKindOrNullSentinel));
}
if (recoveredLines.Count == 0)
diff --git a/src/Platform/Microsoft.Testing.Extensions.PackagedApp/Microsoft.Testing.Extensions.PackagedApp.csproj b/src/Platform/Microsoft.Testing.Extensions.PackagedApp/Microsoft.Testing.Extensions.PackagedApp.csproj
index 42557ff227..b4ddbb91f7 100644
--- a/src/Platform/Microsoft.Testing.Extensions.PackagedApp/Microsoft.Testing.Extensions.PackagedApp.csproj
+++ b/src/Platform/Microsoft.Testing.Extensions.PackagedApp/Microsoft.Testing.Extensions.PackagedApp.csproj
@@ -46,6 +46,7 @@ $(CommonProductDescription)]]>
+
diff --git a/src/Platform/Microsoft.Testing.Extensions.Retry/Microsoft.Testing.Extensions.Retry.csproj b/src/Platform/Microsoft.Testing.Extensions.Retry/Microsoft.Testing.Extensions.Retry.csproj
index ed81db2d47..d3683f2b1e 100644
--- a/src/Platform/Microsoft.Testing.Extensions.Retry/Microsoft.Testing.Extensions.Retry.csproj
+++ b/src/Platform/Microsoft.Testing.Extensions.Retry/Microsoft.Testing.Extensions.Retry.csproj
@@ -28,6 +28,7 @@
+
diff --git a/src/Platform/Microsoft.Testing.Extensions.Retry/RetryOrchestrator.ArtifactRecovery.cs b/src/Platform/Microsoft.Testing.Extensions.Retry/RetryOrchestrator.ArtifactRecovery.cs
index 5f0e01fc61..f8f334b51f 100644
--- a/src/Platform/Microsoft.Testing.Extensions.Retry/RetryOrchestrator.ArtifactRecovery.cs
+++ b/src/Platform/Microsoft.Testing.Extensions.Retry/RetryOrchestrator.ArtifactRecovery.cs
@@ -12,9 +12,6 @@ internal sealed partial class RetryOrchestrator
private const string AppContainerArtifactRootsConfiguredEnvironmentVariable = "TESTINGPLATFORM_PACKAGEDAPP_APPCONTAINER_ARTIFACT_ROOTS_CONFIGURED";
private const string ArtifactPathDestinationRootEnvironmentVariable = "TESTINGPLATFORM_ARTIFACT_PATH_DESTINATION_ROOT";
private const string DiagnosticArtifactPathDestinationRootEnvironmentVariable = "TESTINGPLATFORM_DIAGNOSTIC_ARTIFACT_PATH_DESTINATION_ROOT";
- private const long MaxRecoveredArtifactManifestBytes = 16L * 1024 * 1024;
- private const int MaxRecoveredArtifactManifestLineBytes = 64 * 1024;
- private const int MaxRecoveredArtifactManifestRecords = 10_000;
private const int MaxRecoveredArtifactPathChars = 32 * 1024;
private const int MaxRecoveredArtifactKindChars = 1024;
@@ -35,7 +32,7 @@ private static void CollectRecoveredArtifacts(
using IFileStream stream = fileSystem.NewFileStream(manifestPath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
var reader = new BoundedManifestLineReader(stream.Stream);
int recordCount = 0;
- while (recordCount++ < MaxRecoveredArtifactManifestRecords)
+ while (recordCount++ < RetryArtifactManifest.MaxRecords)
{
BoundedManifestLineReadResult readResult = reader.ReadLine(out string line);
if (readResult == BoundedManifestLineReadResult.End)
@@ -49,8 +46,7 @@ private static void CollectRecoveredArtifacts(
return;
}
- int separatorIndex = line.IndexOf('\t');
- if (separatorIndex <= 0)
+ if (!RetryArtifactManifest.TrySplitEntry(line, out string? encodedPath, out string? encodedKindOrNullSentinel))
{
logger.LogWarning($"Ignoring malformed recovered retry artifact manifest entry in '{manifestPath}'.");
continue;
@@ -58,11 +54,8 @@ private static void CollectRecoveredArtifacts(
try
{
- string path = Encoding.UTF8.GetString(Convert.FromBase64String(line.Substring(0, separatorIndex)));
- string encodedKind = line.Substring(separatorIndex + 1);
- string? kind = encodedKind == "-"
- ? null
- : Encoding.UTF8.GetString(Convert.FromBase64String(encodedKind));
+ string path = RetryArtifactManifest.DecodePath(encodedPath);
+ string? kind = RetryArtifactManifest.DecodeKind(encodedKindOrNullSentinel);
if (path.Length > MaxRecoveredArtifactPathChars
|| kind?.Length > MaxRecoveredArtifactKindChars)
{
@@ -101,7 +94,7 @@ private static void CollectRecoveredArtifacts(
}
}
- logger.LogWarning($"Stopped reading recovered retry artifact manifest '{manifestPath}' after the maximum of {MaxRecoveredArtifactManifestRecords} records.");
+ logger.LogWarning($"Stopped reading recovered retry artifact manifest '{manifestPath}' after the maximum of {RetryArtifactManifest.MaxRecords} records.");
}
catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
{
@@ -195,7 +188,7 @@ private sealed class BoundedManifestLineReader(Stream stream)
private const int BufferSize = 8192;
private readonly byte[] _readBuffer = new byte[BufferSize];
- private readonly byte[] _lineBuffer = new byte[MaxRecoveredArtifactManifestLineBytes];
+ private readonly byte[] _lineBuffer = new byte[RetryArtifactManifest.MaxLineLength];
private int _readOffset;
private int _readCount;
private long _bytesRead;
@@ -205,7 +198,7 @@ public BoundedManifestLineReadResult ReadLine(out string line)
int lineLength = 0;
while (TryReadByte(out byte value))
{
- if (++_bytesRead > MaxRecoveredArtifactManifestBytes)
+ if (++_bytesRead > RetryArtifactManifest.MaxBytes)
{
line = string.Empty;
return BoundedManifestLineReadResult.LimitExceeded;
@@ -216,7 +209,7 @@ public BoundedManifestLineReadResult ReadLine(out string line)
return DecodeLine(lineLength, out line);
}
- if (lineLength >= MaxRecoveredArtifactManifestLineBytes)
+ if (lineLength >= RetryArtifactManifest.MaxLineLength)
{
line = string.Empty;
return BoundedManifestLineReadResult.LimitExceeded;
diff --git a/src/Platform/SharedExtensionHelpers/ReportProcessLifetimeHandler.cs b/src/Platform/SharedExtensionHelpers/ReportProcessLifetimeHandler.cs
index dbc02d2e00..c39693eb84 100644
--- a/src/Platform/SharedExtensionHelpers/ReportProcessLifetimeHandler.cs
+++ b/src/Platform/SharedExtensionHelpers/ReportProcessLifetimeHandler.cs
@@ -183,10 +183,7 @@ private async Task WriteRetryArtifactManifestAsync(
_fileSystem.CreateDirectory(directory);
}
- string encodedPath = Convert.ToBase64String(Encoding.UTF8.GetBytes(artifactPath));
- string encodedKind = artifactKind is null
- ? "-"
- : Convert.ToBase64String(Encoding.UTF8.GetBytes(artifactKind));
+ string entry = RetryArtifactManifest.WriteEntry(artifactPath, artifactKind);
using IFileStream stream = _fileSystem.NewFileStream(
manifestPath,
FileMode.Append,
@@ -194,10 +191,10 @@ private async Task WriteRetryArtifactManifestAsync(
FileShare.Read);
using var writer = new StreamWriter(stream.Stream, new UTF8Encoding(encoderShouldEmitUTF8Identifier: false));
#if NETCOREAPP
- await writer.WriteLineAsync($"{encodedPath}\t{encodedKind}".AsMemory(), cancellationToken).ConfigureAwait(false);
+ await writer.WriteLineAsync(entry.AsMemory(), cancellationToken).ConfigureAwait(false);
#else
cancellationToken.ThrowIfCancellationRequested();
- await writer.WriteLineAsync($"{encodedPath}\t{encodedKind}").ConfigureAwait(false);
+ await writer.WriteLineAsync(entry).ConfigureAwait(false);
#endif
}
catch (Exception ex) when (ex is not OperationCanceledException)
diff --git a/src/Platform/SharedExtensionHelpers/RetryArtifactManifest.cs b/src/Platform/SharedExtensionHelpers/RetryArtifactManifest.cs
new file mode 100644
index 0000000000..98ca45af29
--- /dev/null
+++ b/src/Platform/SharedExtensionHelpers/RetryArtifactManifest.cs
@@ -0,0 +1,49 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+namespace Microsoft.Testing.Extensions;
+
+#pragma warning disable RS0051 // Recovery infrastructure is shared-source implementation detail, not package API.
+
+internal static class RetryArtifactManifest
+{
+ public const long MaxBytes = 16L * 1024 * 1024;
+ public const int MaxLineLength = 64 * 1024;
+ public const int MaxRecords = 10_000;
+
+ public static bool TrySplitEntry(
+ string line,
+ [NotNullWhen(true)] out string? encodedPath,
+ [NotNullWhen(true)] out string? encodedKindOrNullSentinel)
+ {
+ int separatorIndex = line.IndexOf('\t');
+ if (separatorIndex <= 0)
+ {
+ encodedPath = null;
+ encodedKindOrNullSentinel = null;
+ return false;
+ }
+
+ encodedPath = line.Substring(0, separatorIndex);
+ encodedKindOrNullSentinel = line.Substring(separatorIndex + 1);
+ return true;
+ }
+
+ public static string DecodePath(string encodedPath)
+ => Encoding.UTF8.GetString(Convert.FromBase64String(encodedPath));
+
+ public static string? DecodeKind(string encodedKindOrNullSentinel)
+ => encodedKindOrNullSentinel == "-"
+ ? null
+ : Encoding.UTF8.GetString(Convert.FromBase64String(encodedKindOrNullSentinel));
+
+ public static string WriteEntryWithEncodedKind(string path, string encodedKindOrNullSentinel)
+ => $"{Convert.ToBase64String(Encoding.UTF8.GetBytes(path))}\t{encodedKindOrNullSentinel}";
+
+ public static string WriteEntry(string path, string? kind)
+ => WriteEntryWithEncodedKind(
+ path,
+ kind is null ? "-" : Convert.ToBase64String(Encoding.UTF8.GetBytes(kind)));
+}
+
+#pragma warning restore RS0051
diff --git a/test/UnitTests/Microsoft.Testing.Extensions.UnitTests/RetryTests.cs b/test/UnitTests/Microsoft.Testing.Extensions.UnitTests/RetryTests.cs
index c2757615ed..c0d57ae030 100644
--- a/test/UnitTests/Microsoft.Testing.Extensions.UnitTests/RetryTests.cs
+++ b/test/UnitTests/Microsoft.Testing.Extensions.UnitTests/RetryTests.cs
@@ -372,13 +372,79 @@ public void CollectRecoveredArtifacts_RecoveredKind_ReplacesPreviouslyPublishedA
fileSystem.Verify(fs => fs.DeleteFile(manifestPath), Times.Once);
}
+ [TestMethod]
+ public void CollectRecoveredArtifacts_NullKind_AddsRecoveredArtifact()
+ {
+ const string manifestPath = "recovered-artifacts.txt";
+ string attemptDirectory = Path.GetFullPath("attempt");
+ string recoveredArtifactPath = Path.Combine(attemptDirectory, "recovered.xml");
+ var fileSystem = new Mock();
+ fileSystem.Setup(fs => fs.ExistFile(It.IsAny())).Returns(true);
+ fileSystem.Setup(fs => fs.NewFileStream(manifestPath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
+ .Returns(new ReadOnlyMemoryFileStream(CreateManifestLine(recoveredArtifactPath, kind: null)));
+ List artifacts = [];
+
+ InvokeCollectRecoveredArtifacts(fileSystem.Object, manifestPath, attemptDirectory, artifacts);
+
+ ArtifactRequest artifact = Assert.ContainsSingle(artifacts);
+ Assert.AreEqual(recoveredArtifactPath, artifact.Path);
+ Assert.IsNull(artifact.Kind);
+ fileSystem.Verify(fs => fs.DeleteFile(manifestPath), Times.Once);
+ }
+
+ [TestMethod]
+ public void RetryArtifactManifest_WriteEntry_RoundTripsNonNullKind()
+ {
+ const string path = "report\t✓.xml";
+ const string kind = "microsoft.testing\tjunit✓";
+
+ string entry = InvokeWriteManifestEntry(path, kind);
+
+ Assert.HasCount(2, entry.Split('\t'));
+ (string encodedPath, string encodedKindOrNullSentinel) = SplitManifestEntry(entry);
+ Assert.AreEqual(path, DecodeManifestPath(encodedPath));
+ Assert.AreEqual(kind, DecodeManifestKind(encodedKindOrNullSentinel));
+ }
+
+ [TestMethod]
+ public void RetryArtifactManifest_WriteEntry_RoundTripsNullKind()
+ {
+ const string path = "report.xml";
+
+ string entry = InvokeWriteManifestEntry(path, kind: null);
+
+ Assert.HasCount(2, entry.Split('\t'));
+ (string encodedPath, string encodedKindOrNullSentinel) = SplitManifestEntry(entry);
+ Assert.AreEqual(path, DecodeManifestPath(encodedPath));
+ Assert.AreEqual("-", encodedKindOrNullSentinel);
+ Assert.IsNull(DecodeManifestKind(encodedKindOrNullSentinel));
+ }
+
+ [TestMethod]
+ public void RetryArtifactManifest_WriteEntryWithEncodedKind_RoundTripsEncodedKind()
+ {
+ const string path = "report.xml";
+ const string kind = "microsoft.testing.junit";
+ string encodedKind = Convert.ToBase64String(Encoding.UTF8.GetBytes(kind));
+
+ string entry = InvokeWriteManifestEntryWithEncodedKind(path, encodedKind);
+
+ Assert.HasCount(2, entry.Split('\t'));
+ (string encodedPath, string encodedKindOrNullSentinel) = SplitManifestEntry(entry);
+ Assert.AreEqual(encodedKind, encodedKindOrNullSentinel);
+ Assert.AreEqual(path, DecodeManifestPath(encodedPath));
+ Assert.AreEqual(kind, DecodeManifestKind(encodedKindOrNullSentinel));
+ }
+
[TestMethod]
public void CollectRecoveredArtifacts_OversizedLine_IsRejectedAndManifestIsDeleted()
{
const string manifestPath = "recovered-artifacts.txt";
string attemptDirectory = Path.GetFullPath("attempt");
- int maxLineBytes = (int)typeof(RetryOrchestrator)
- .GetField("MaxRecoveredArtifactManifestLineBytes", BindingFlags.Static | BindingFlags.NonPublic)!
+ Type manifestType = typeof(RetryOrchestrator).Assembly
+ .GetType("Microsoft.Testing.Extensions.RetryArtifactManifest")!;
+ int maxLineBytes = (int)manifestType
+ .GetField("MaxLineLength", BindingFlags.Static | BindingFlags.Public)!
.GetRawConstantValue()!;
var fileSystem = new Mock();
fileSystem.Setup(fs => fs.ExistFile(manifestPath)).Returns(true);
@@ -398,8 +464,10 @@ public void CollectRecoveredArtifacts_RecordLimit_IsEnforcedAndManifestIsDeleted
const string manifestPath = "recovered-artifacts.txt";
string attemptDirectory = Path.GetFullPath("attempt");
string recoveredArtifactPath = Path.Combine(attemptDirectory, "recovered.xml");
- int maxRecords = (int)typeof(RetryOrchestrator)
- .GetField("MaxRecoveredArtifactManifestRecords", BindingFlags.Static | BindingFlags.NonPublic)!
+ Type manifestType = typeof(RetryOrchestrator).Assembly
+ .GetType("Microsoft.Testing.Extensions.RetryArtifactManifest")!;
+ int maxRecords = (int)manifestType
+ .GetField("MaxRecords", BindingFlags.Static | BindingFlags.Public)!
.GetRawConstantValue()!;
var manifest = new StringBuilder();
for (int i = 0; i < maxRecords; i++)
@@ -1279,7 +1347,42 @@ private static ServiceProvider CreateServiceProvider(params IArtifactPostProcess
}
private static string CreateManifestLine(string path, string? kind)
- => $"{Convert.ToBase64String(Encoding.UTF8.GetBytes(path))}\t{(kind is null ? "-" : Convert.ToBase64String(Encoding.UTF8.GetBytes(kind)))}";
+ => InvokeWriteManifestEntry(path, kind);
+
+ private static string InvokeWriteManifestEntry(string path, string? kind)
+ => (string)GetRetryArtifactManifestType()
+ .GetMethod("WriteEntry", BindingFlags.Static | BindingFlags.Public)!
+ .Invoke(null, [path, kind])!;
+
+ private static string InvokeWriteManifestEntryWithEncodedKind(string path, string encodedKindOrNullSentinel)
+ => (string)GetRetryArtifactManifestType()
+ .GetMethod("WriteEntryWithEncodedKind", BindingFlags.Static | BindingFlags.Public)!
+ .Invoke(null, [path, encodedKindOrNullSentinel])!;
+
+ private static (string EncodedPath, string EncodedKindOrNullSentinel) SplitManifestEntry(string entry)
+ {
+ object?[] arguments = [entry, null, null];
+ bool wasSplit = (bool)GetRetryArtifactManifestType()
+ .GetMethod("TrySplitEntry", BindingFlags.Static | BindingFlags.Public)!
+ .Invoke(null, arguments)!;
+
+ Assert.IsTrue(wasSplit);
+ return ((string)arguments[1]!, (string)arguments[2]!);
+ }
+
+ private static string DecodeManifestPath(string encodedPath)
+ => (string)GetRetryArtifactManifestType()
+ .GetMethod("DecodePath", BindingFlags.Static | BindingFlags.Public)!
+ .Invoke(null, [encodedPath])!;
+
+ private static string? DecodeManifestKind(string encodedKindOrNullSentinel)
+ => (string?)GetRetryArtifactManifestType()
+ .GetMethod("DecodeKind", BindingFlags.Static | BindingFlags.Public)!
+ .Invoke(null, [encodedKindOrNullSentinel]);
+
+ private static Type GetRetryArtifactManifestType()
+ => typeof(RetryOrchestrator).Assembly
+ .GetType("Microsoft.Testing.Extensions.RetryArtifactManifest")!;
private static void InvokeCollectRecoveredArtifacts(
IFileSystem fileSystem,