public static void Enable(bool captureLogs = true)
{
if (captureLogs)
{
LogCapture.Initialize();
}
VerifierSettings.ModifySerialization(settings =>
{
settings.IgnoreMember <TestableInvokeHandlerContext>(x => x.MessageHeaders);
settings.IgnoreMember <TestableInvokeHandlerContext>(x => x.Headers);
settings.IgnoreMember <TestableInvokeHandlerContext>(x => x.MessageId);
settings.IgnoreMember <TestableInvokeHandlerContext>(x => x.MessageHandler);
settings.IgnoreMember <TestableInvokeHandlerContext>(x => x.MessageBeingHandled);
settings.IgnoreMember <TestableInvokeHandlerContext>(x => x.MessageMetadata);
settings.IgnoreMember <IMessageProcessingContext>(x => x.ReplyToAddress);
settings.IgnoreMember <TestableEndpointInstance>(x => x.EndpointStopped);
settings.IgnoreMember <TestableOutgoingLogicalMessageContext>(x => x.RoutingStrategies);
settings.IgnoreMember <TestableOutgoingPhysicalMessageContext>(x => x.RoutingStrategies);
settings.IgnoreMember <TestableRoutingContext>(x => x.RoutingStrategies);
settings.IgnoreInstance <ContextBag>(x => !ContextBagHelper.HasContent(x));
settings.IgnoreMembersWithType <IBuilder>();
settings.AddExtraSettings(serializerSettings =>
{
var converters = serializerSettings.Converters;
converters.Add(new ContextBagConverter());
converters.Add(new SendOptionsConverter());
converters.Add(new ExtendableOptionsConverter());
converters.Add(new UnsubscriptionConverter());
converters.Add(new TimeoutMessageConverter());
converters.Add(new MessageToHandlerMapConverter());
converters.Add(new SubscriptionConverter());
converters.Add(new OutgoingMessageConverter());
});
});
}
public void BeforeEachTest()
{
VerifierSettings.UseStrictJson();
server = new HttpTest();
api = new CommerceApi(apiKey);
}
public static void Initialize()
{
VerifierSettings.DisableNewLineEscaping();
VerifyWinForms.Enable();
VerifyImageMagick.Initialize();
VerifyImageMagick.RegisterComparers();
}
public async Task WithStreamRequiringCleanup()
{
object?info = null;
var filePath = "WithStreamRequiringCleanup.tmp";
File.WriteAllText(filePath, "FileContent");
VerifierSettings.RegisterFileConverter <TargetForCleanup>(
(_, _) =>
{
#region ConversionResultWithCleanup
return(new ConversionResult(
info: info,
"bin",
stream: File.OpenRead(filePath),
cleanup: () =>
{
File.Delete(filePath);
return Task.CompletedTask;
}));
#endregion
});
TargetForCleanup target = new()
{
Value = "line1"
};
await Verifier.Verify(target);
Assert.False(File.Exists(filePath));
}
static Tests()
{
VerifyDiffPlex.Initialize();
VerifierSettings.DisableClipboard();
VerifierSettings.ModifySerialization(
settings => settings.IgnoreMember <Exception>(_ => _.StackTrace));
}
public Task VisualStudioEditorsSetup()
{
IEnumerable <string> files = GetPackageContents("VisualStudioEditorsSetup.vsix");
VerifierSettings.ScrubLinesContaining(DigitalSignature, Rels);
return(Verifier.Verify(files));
}
public static string GetUniqueTestName(string className, MethodInfo method, IReadOnlyList <object?>?parameterValues)
{
var name = $"{className}.{method.Name}";
if (parameterValues == null || !parameterValues.Any())
{
return(name);
}
var builder = new StringBuilder();
var parameters = method.GetParameters();
for (var index = 0; index < parameters.Length; index++)
{
var parameter = parameters[index];
var parameterValue = parameterValues[index];
builder.Append($"{parameter.Name}=");
if (parameterValue == null)
{
builder.Append("null_");
continue;
}
builder.Append($"{VerifierSettings.GetNameForParameter(parameterValue)}_");
}
builder.Length -= 1;
return($"{name}_{builder}");
}
static Tests()
{
BuildServerDetector.Detected = false;
DiffRunner.Disabled = false;
DiffTools.AddTool(
name: "MyTools",
autoRefresh: true,
isMdi: false,
supportsText: true,
requiresTarget: true,
arguments: (path1, path2) => $"\"{path1}\" \"{path2}\"",
exePath: diffToolPath,
binaryExtensions: new[] { "knownBin" },
shellExecute: false);
var binPath = AllFiles.Files["jpg"];
var newPath = Path.ChangeExtension(binPath.Path, "knownBin");
File.Copy(binPath.Path, newPath, true);
AllFiles.UseFile(Category.Image, newPath);
VerifierSettings.RegisterFileConverter <TypeToSplit>(
(split, settings) => new ConversionResult(
split.Info,
new List <ConversionStream>
{
new ConversionStream("txt", new MemoryStream(FileHelpers.Utf8NoBOM.GetBytes(split.Property1))),
new ConversionStream("txt", new MemoryStream(FileHelpers.Utf8NoBOM.GetBytes(split.Property2)))
}));
DiffRunner.MaxInstancesToLaunch(int.MaxValue);
}
public PlaidClientTest()
{
VerifierSettings.DisableClipboard();
VerifierSettings.ScrubLinesContaining(StringComparison.OrdinalIgnoreCase, "RequestId");
VerifierSettings.UseStrictJson();
var configuration = new ConfigurationBuilder()
.AddEnvironmentVariables()
.AddJsonFile("secrets.json", optional: true)
.Build();
var plaidOptions = configuration.GetSection(PlaidOptions.SectionKey).Get <PlaidOptions>();
if (string.IsNullOrWhiteSpace(plaidOptions?.ClientId))
{
throw new InvalidOperationException("Please provide ClientId configuration via PLAID__CLIENTID environment variable or Plaid:ClientId in secrets.json.");
}
if (string.IsNullOrWhiteSpace(plaidOptions?.Secret))
{
throw new InvalidOperationException("Please provide Secret configuration via PLAID__SECRET or Plaid:Secret in secrets.json.");
}
if (string.IsNullOrWhiteSpace(plaidOptions?.DefaultAccessToken))
{
throw new InvalidOperationException("Please provide DefaultAccessToken configuration via PLAID__DEFAULTACCESSTOKEN or Plaid:DefaultAccessToken in secrets.json.");
}
PlaidClient = new PlaidClient(
MOptions.Create(plaidOptions));
}
public Task ProjectSystem()
{
IEnumerable <string> files = GetPackageContents("ProjectSystem.vsix");
VerifierSettings.ScrubLinesContaining(DigitalSignature, Rels);
return(Verifier.Verify(files));
}
public static void Init()
{
VerifierSettings.ModifySerialization(
settings =>
{
settings.AddExtraSettings(x =>
{
x.Converters.Add(new ResultConverter());
x.Converters.Add(new TimestampConverter());
});
#if NET5_0
settings.IgnoreMember <System.Net.Http.HttpRequestException>(x => x.StatusCode);
#endif
settings.IgnoreMember <Result>(x => x.File);
settings.IgnoreMembers(
"StackTrace",
"Content-Length",
"TrailingHeaders",
"X-Amzn-Trace-Id",
"Set-Cookie",
"Report-To",
"Connection",
"Server-Timing",
"Content-Type",
"NEL",
"Accept-Ranges",
"Age",
"Server",
"X-Client-IP",
"Strict-Transport-Security",
"X-Cache-Status",
"X-Cache",
"origin");
});
}
void Converter()
{
#region JsonConverter
VerifierSettings.AddExtraSettings(_ => { _.Converters.Add(new CompanyConverter()); });
#endregion
}
public static void Setup()
{
VerifierSettings.ModifySerialization(settings =>
{
settings.IgnoreMembersThatThrow(x => x.Message == "Cannot escape out of a Tree.");
settings.IgnoreMember <Parts>(x => x.Sha);
});
}
public static void Enable() =>
VerifierSettings
.AddExtraSettings(_ =>
{
var converters = _.Converters;
converters.Add(new SessionConverter());
converters.Add(new LazyStringValueConverter());
});
void DontIgnoreFalse()
{
#region DontIgnoreFalse
VerifierSettings.ModifySerialization(_ => _.DontIgnoreFalse());
#endregion
}
public Task AsyncExtensionConversion()
{
VerifierSettings.RegisterFileConverter(
"AsyncExtensionConversion",
(_, _) => Task.FromResult(new ConversionResult(null, "txt", "Foo")));
return(Verifier.Verify(new MemoryStream())
.UseExtension("AsyncExtensionConversion"));
}
public Task TextSplit()
{
VerifierSettings.RegisterFileConverter(
"split",
(stream, _) => new(null, "txt", stream));
return(Verifier.Verify(FileHelpers.OpenRead("sample.split"))
.UseExtension("txt"));
}
static Tests()
{
#region UseStrictJson
VerifierSettings.UseStrictJson();
#endregion
}
static DisableDirScrubbingTests()
{
VerifierSettings.DontScrubSolutionDirectory();
VerifierSettings.DontScrubProjectDirectory();
var solutionDirectory = AttributeReader.GetSolutionDirectory();
VerifierSettings.AddScrubber(s => s.Replace(solutionDirectory, "CustomReplace\\"));
}
void DisableClipboardGlobal()
{
#region DisableClipboardGlobal
VerifierSettings.DisableClipboard();
#endregion
}
void ScrubInlineGuids()
{
#region ScrubInlineGuids
VerifierSettings.ScrubInlineGuids();
#endregion
}
void DontIgnoreEmptyCollections()
{
#region DontIgnoreEmptyCollections
VerifierSettings.ModifySerialization(_ => _.DontIgnoreEmptyCollections());
#endregion
}
public ApiApprovalTests()
: base()
{
verifySettings = new VerifySettings();
verifySettings.UseExtension("cs");
VerifierSettings.OnVerifyMismatch((filePair, message) => DiffPlexReporter.Report(filePair.Received, filePair.Verified, message));
}
public Task ExtensionConversionStringBuilder()
{
VerifierSettings.RegisterFileConverter(
"ExtensionConversionStringBuilder",
(_, _) => new ConversionResult(null, "txt", new StringBuilder("Foo")));
return(Verifier.Verify(new MemoryStream())
.UseExtension("ExtensionConversionStringBuilder"));
}
void DontScrubProjectDirectory()
{
#region DontScrubProjectDirectory
VerifierSettings.DontScrubProjectDirectory();
#endregion
}
void DontScrubSolutionDirectory()
{
#region DontScrubSolutionDirectory
VerifierSettings.DontScrubSolutionDirectory();
#endregion
}
void DontScrubDateTimes()
{
#region DontScrubDateTimes
VerifierSettings.ModifySerialization(_ => _.DontScrubDateTimes());
#endregion
}
public Task TreatAsString()
{
VerifierSettings.TreatAsString <ClassWithToString>(
(target, _) => target.Property);
return(Verifier.Verify(new ClassWithToString {
Property = "Foo"
}));
}
internal bool TryFindComparer(out Compare?compare)
{
if (comparer != null)
{
compare = comparer;
return(true);
}
return(VerifierSettings.TryGetComparer(ExtensionOrTxt(), out compare));
}
void TreatAsString()
{
#region TreatAsString
VerifierSettings.TreatAsString <ClassWithToString>(
(target, settings) => target.Property);
#endregion
}
