public static async Task <EqualityResult> Streams(
VerifySettings settings,
Stream stream,
FilePair file)
{
await FileHelpers.WriteStream(file.Received, stream);
var result = await FileComparer.DoCompare(settings, file);
if (result.Equality == Equality.Equal)
{
File.Delete(file.Received);
}
return(result);
}
public Task TypeConversion()
{
VerifierSettings.RegisterFileConverter <Bitmap>(
canConvert: (target, _) => Equals(target.RawFormat, ImageFormat.Bmp),
conversion: (bitmap1, _) =>
{
var streams = ConvertBmpTpPngStreams(bitmap1);
return(new ConversionResult(null, streams.Select(x => new ConversionStream("png", x))));
});
var settings = new VerifySettings();
settings.UseExtension("bmp");
var bitmap = new Bitmap(FileHelpers.OpenRead("sample.bmp"));
return(Verifier.Verify(bitmap, settings));
}
static VerifySettings GetConverterSettings(VerifySettings settings, TypeConverter converter)
{
if (converter.ToExtension != null)
{
var converterSettings = new VerifySettings(settings);
converterSettings.UseExtension(converter.ToExtension);
return(converterSettings);
}
if (settings.HasExtension())
{
return(settings);
}
throw new Exception("No extension defined.");
}
public async Task Query_List_Works(CollectionCaseData caseData)
{
// Arrange
var executor = await GetRequestExecutorAsync();
var query = "query { readWithListArg(foos: " + caseData.FoosInput + ") }";
// Act
var result = await executor.ExecuteAsync(query);
// Assert
var verifySettings = new VerifySettings();
verifySettings.UseParameters(caseData.CaseId);
await Verifier.Verify(result, verifySettings);
}
public Task TypeConversion()
{
SharedVerifySettings.RegisterFileConverter <Bitmap>(
"png",
(bitmap1, _) =>
{
var streams = ConvertBmpTpPngStreams(bitmap1);
return(new ConversionResult(null, streams));
});
var settings = new VerifySettings();
settings.UseExtension("bmp");
var bitmap = new Bitmap(FileHelpers.OpenRead("sample.bmp"));
return(Verify(bitmap, settings));
}
public async Task Mutation_Works(CaseData caseData)
{
// Arrange
var executor = await GetRequestExecutorAsync();
var query = "mutation { write(foo: " + caseData.FooInput + ", bar: " + caseData.BarInput + ") }";
// Act
var result = await executor.ExecuteAsync(query);
// Assert
var verifySettings = new VerifySettings();
verifySettings.UseParameters(caseData);
await Verifier.Verify(result, verifySettings);
}
async Task RunTest(
string extension,
Func <object> initialTarget,
Func <object> secondTarget,
bool hasMatchingDiffTool,
bool hasExistingReceived,
bool autoVerify,
VerifySettings settings,
string uniqueTestName)
{
settings.UseExtension(extension);
if (autoVerify)
{
settings.AutoVerify();
}
var prefix = Path.Combine(SourceDirectory, uniqueTestName);
var danglingFile = Path.Combine(SourceDirectory, $"{prefix}.01.verified.{extension}");
FilePair file = new(extension, prefix);
DeleteAll(danglingFile, file.Verified, file.Received);
File.WriteAllText(danglingFile, "");
if (hasExistingReceived)
{
File.WriteAllText(file.Received, "");
}
await InitialVerify(initialTarget, hasMatchingDiffTool, settings, file);
if (!autoVerify)
{
RunClipboardCommand();
}
AssertNotExists(danglingFile);
await ReVerify(initialTarget, settings, file);
await InitialVerify(secondTarget, hasMatchingDiffTool, settings, file);
if (!autoVerify)
{
RunClipboardCommand();
}
await ReVerify(secondTarget, settings, file);
}
static VerifyImages()
{
VerifierSettings.RegisterFileConverter("pdf", ConvertPdfToPng);
VerifyImageMagick.RegisterComparers(threshold: 0.1, ImageMagick.ErrorMetric.PerceptualHash);
SvgSettings = new VerifySettings();
SvgSettings.UseExtension("svg");
SvgSettings.UseDirectory("ReferenceFiles");
PngSettings = new VerifySettings();
PngSettings.UseExtension("png");
PngSettings.UseDirectory("ReferenceFiles");
PdfSettings = new VerifySettings();
PdfSettings.UseExtension("pdf");
PdfSettings.UseDirectory("ReferenceFiles");
}
async Task VerifyInfo(VerifyEngine engine, VerifySettings settings, object?info)
{
if (info == null)
{
return;
}
var file = GetFileNames("txt", settings.Namer, "info");
var formatJson = JsonFormatter.AsJson(info, settings.serialization.currentSettings);
var scrubbedInput = ScrubInput(formatJson, settings);
var result = await Comparer.Text(file, scrubbedInput);
engine.HandleCompareResult(result, file);
}
private Task Verify(string assemblyName, [CallerFilePath] string sourceFile = "")
{
var verifySettings = new VerifySettings();
verifySettings.UseExtension("cs");
var options = new ApiGeneratorOptions
{
IncludeAssemblyAttributes = false
};
return(Verify(
Assembly
.Load(assemblyName)
.GeneratePublicApi(options),
verifySettings));
}
static async Task ReVerify(Func <object> target, VerifySettings settings, FilePair pair)
{
var command = BuildCommand(pair);
ProcessCleanup.Refresh();
await Verifier.Verify(target(), settings);
await Task.Delay(300);
ProcessCleanup.Refresh();
AssertProcessNotRunning(command);
AssertNotExists(pair.Received);
AssertExists(pair.Verified);
await EnsureUtf8(pair);
}
InnerVerifier BuildVerifier(VerifySettings settings, string sourceFile)
{
var type = GetType();
var methodInfo = type
.GetMethods(BindingFlags.Instance | BindingFlags.Public)
.FirstOrDefault(x => x.Name == TestContext.TestName);
if (methodInfo == null)
{
throw new($"Could not find method `{type.Name}.{TestContext.TestName}`");
}
var parameters = settings.GetParameters(methodInfo);
return(new(sourceFile, type, settings, methodInfo, parameters));
}
public Task ConvertWithExtInSettings()
{
SharedVerifySettings.RegisterFileConverter <ClassToSplit2>(
(instance, _) =>
{
var streams = ToStream(instance.Value);
return(new ConversionResult(null, streams));
});
var target = new ClassToSplit2
{
Value = "line1"
};
var settings = new VerifySettings();
settings.UseExtension("txt");
return(Verifier.Verify(target, settings));
}
public Task Approve()
{
string publicApi = typeof(ConnectionFactory).Assembly.GeneratePublicApi(new ApiGeneratorOptions
{
ExcludeAttributes = new[]
{
"System.Runtime.Versioning.TargetFrameworkAttribute",
"System.Reflection.AssemblyMetadataAttribute"
}
});
var settings = new VerifySettings();
settings.DisableDiff();
return(Verifier.Verify(publicApi, settings));
}
public async Task Works(bool registerValidators)
{
// Arrange
var executor = await GetRequestExecutorAsync(
registerValidators : registerValidators,
configureOptions : options =>
{
if (!registerValidators)
{
options.ThrowIfNoValidatorsFound = false;
}
});
var query = "query { " +
"noArgs " +
"scalarArgsA(a: 0, b: false) " +
"scalarArgsB(a: 0, b: false) " +
"scalarArgsC(a: 0, b: false) " +
"scalarArgsD(a: 0, b: false) " +
"nullableScalarArgsA(a: 0, b: false) " +
"nullableScalarArgsB(a: 0, b: false) " +
"nullableScalarArgsC(a: 0, b: false) " +
"nullableScalarArgsD(a: 0, b: false) " +
"objectArgA(input: { a: 0, b: false }) " +
"objectArgB(input: { a: 0, b: false }) " +
"objectArgC(input: { a: 0, b: false }) " +
"objectArgD(input: { a: 0, b: false }) " +
"arrayArgA(items: [0, 0]) " +
"listArgA(items: [0, 0]) " +
"listArgB(items: [0, 0]) " +
"listArgC(items: [0, 0]) " +
"listArgD(items: [0, 0]) " +
"listOfListArgC(items: [[0, 0], [0, 0]]) " +
"filterSortAndPagingArgs(first: 10) { nodes { a } }" +
"}";
// Act
var result = await executor.ExecuteAsync(query);
// Assert
var verifySettings = new VerifySettings();
verifySettings.UseParameters(registerValidators);
await Verifier.Verify(result, verifySettings);
}
public async Task SettingsArePassed()
{
VerifySettings?fromGlobal = null;
SharedVerifySettings.RegisterComparer(
"SettingsArePassed",
(verifySettings, stream1, stream2) =>
{
fromGlobal = verifySettings;
return(true);
});
var settings = new VerifySettings();
settings.UseExtension("SettingsArePassed");
await Verify(new MemoryStream(new byte[] { 1 }), settings);
Assert.Same(fromGlobal, settings);
}
public Task Inherited()
{
VerifierSettings.RegisterFileConverter <ParentClass>(
(instance, _) =>
{
var streams = ToStream(instance.Value);
return(new ConversionResult(null, streams.Select(x => new ConversionStream("txt", x))));
});
var target = new InheritedClass
{
Value = "line1"
};
var settings = new VerifySettings();
settings.UseExtension("txt");
return(Verifier.Verify(target, settings));
}
public async Task SettingsArePassed()
{
VerifySettings?fromGlobal = null;
VerifierSettings.RegisterComparer(
"SettingsArePassed",
(verifySettings, received, verified) =>
{
fromGlobal = verifySettings;
return(Task.FromResult(new CompareResult(true)));
});
var settings = new VerifySettings();
settings.UseExtension("SettingsArePassed");
await Verifier.Verify(new MemoryStream(new byte[] { 1 }), settings);
Assert.Same(fromGlobal, settings);
}
public static Task <bool> FilesEqual(VerifySettings settings, FilePair file)
{
if (settings.comparer != null)
{
return(DoCompare(settings, file.Received, file.Verified, settings.comparer));
}
if (SharedVerifySettings.TryGetComparer(file.Extension, out var comparer))
{
return(DoCompare(settings, file.Received, file.Verified, comparer));
}
if (!FilesAreSameSize(file))
{
return(Task.FromResult(false));
}
return(DefaultCompare(settings, file.Received, file.Verified));
}
public void ScopedSerializer()
{
#region ScopedSerializer
var person = new Person
{
GivenNames = "John",
FamilyName = "Smith",
Dob = new DateTimeOffset(2000, 10, 1, 0, 0, 0, TimeSpan.Zero),
};
var settings = new VerifySettings();
settings.ModifySerialization(
_ => _.DontScrubDateTimes());
settings.AddExtraSettings(
_ => { _.DateFormatHandling = DateFormatHandling.MicrosoftDateFormat; });
#endregion
}
public async Task Text(
bool hasExistingReceived,
bool autoVerify)
{
var uniqueTestName = TestNameBuilder.GetUniqueTestName("Tests_Single", Info.OfMethod <Tests>("Text"), new object[] { hasExistingReceived, autoVerify });
var settings = new VerifySettings();
settings.UseParameters(hasExistingReceived, autoVerify);
await RunTest(
"txt",
() => "someText",
() => "someOtherText",
hasMatchingDiffTool : true,
hasExistingReceived,
autoVerify,
settings,
uniqueTestName);
}
public Task WithInfo()
{
VerifierSettings.RegisterFileConverter(
"bmp",
(stream, _) =>
{
var info = new
{
Property = "Value"
};
var streams = ConvertBmpTpPngStreams(stream);
return(new ConversionResult(info, streams.Select(x => new ConversionStream("png", x))));
});
var settings = new VerifySettings();
settings.UseExtension("bmp");
return(Verifier.Verify(FileHelpers.OpenRead("sample.bmp"), settings));
}
public static async Task <CompareResult> DoCompare(VerifySettings settings, FilePair file)
{
if (!File.Exists(file.Verified))
{
return(CompareResult.MissingVerified);
}
if (AllFiles.IsEmptyFile(file.Verified))
{
return(CompareResult.NotEqual);
}
if (!await FilesEqual(settings, file))
{
return(CompareResult.NotEqual);
}
return(CompareResult.Equal);
}
public static ConversionResult Convert(IRenderedFragment fragment, VerifySettings settings)
{
var stream = new MemoryStream();
using var writer = stream.BuildLeaveOpenWriter();
var markup = fragment.Markup;
writer.WriteLine(markup);
var instance = ComponentReader.GetInstance(fragment);
var all = fragment.FindAll("*");
var info = new FragmentInfo(
instance,
fragment.RenderCount,
all.Count,
markup.Replace("\r\n", "\n").Length.ToString("N0"));
return(new ConversionResult(info, new [] { new ConversionStream("html", stream) }));
}
public async Task Query_Works(CaseData caseData)
{
// Arrange
var executor = await GetRequestExecutorAsync(options =>
{
options.ShouldValidate = (ctx, arg) => ctx.Operation.Operation == OperationType.Query;
});
var query = "query { read(foo: " + caseData.FooInput + ", bar: " + caseData.BarInput + ") }";
// Act
var result = await executor.ExecuteAsync(query);
// Assert
var verifySettings = new VerifySettings();
verifySettings.UseParameters(caseData);
await Verifier.Verify(result, verifySettings);
}
public async Task OnHandlersSample()
{
var settings = new VerifySettings();
settings.OnFirstVerify(
receivedFile =>
{
Debug.WriteLine(receivedFile);
return(Task.CompletedTask);
});
settings.OnVerifyMismatch(
(receivedFile, verifiedFile) =>
{
Debug.WriteLine(receivedFile);
Debug.WriteLine(verifiedFile);
return(Task.CompletedTask);
});
await Verify("value", settings);
}
static InnerVerifier BuildVerifier(string sourceFile, VerifySettings settings)
{
Guard.AgainstNullOrEmpty(sourceFile, nameof(sourceFile));
var context = TestContext.CurrentContext;
var adapter = context.Test;
var test = (Test)field.GetValue(adapter) !;
if (test.TypeInfo == null || test.Method == null)
{
throw new("Expected Test.TypeInfo and Test.Method to not be null. Raise a Pull Request with a test that replicates this problem.");
}
return(new(
sourceFile,
test.TypeInfo !.Type,
settings,
test.Method !.MethodInfo,
adapter.Arguments));
}
public async Task Static_with_message()
{
EmptyFiles.Extensions.AddTextExtension("staticComparerExtMessage");
VerifierSettings.RegisterStringComparer("staticComparerExtMessage", CompareWithMessage);
var settings = new VerifySettings();
settings.UseExtension("staticComparerExtMessage");
settings.DisableDiff();
var exception = await Assert.ThrowsAsync <Exception>(() => Verifier.Verify("TheText", settings));
Assert.Equal(
@"Results do not match.
Differences:
Received: ComparerTests.Static_with_message.received.staticComparerExtMessage
Verified: ComparerTests.Static_with_message.verified.staticComparerExtMessage
Compare Result:
theMessage".Replace("\r\n", "\n"),
exception.Message.Trim().Replace("\r\n", "\n").Replace("Use DiffEngineTray to verify files.\n", ""));
}
public Task ShouldBeAbleToExcludeInlineGuids()
{
var id = Guid.NewGuid();
var product = new
{
Title = $"item {id} - (ID={{{id}}})",
Variant = new
{
Id = "variant id: " + id
}
};
var settings = new VerifySettings();
settings.ModifySerialization(_ =>
{
_.ScrubInlineGuids();
});
return(Verify(product, settings));
}
static Task <CompareResult> CompareImages(
VerifySettings settings,
Stream received,
Stream verified)
{
var hash1 = HashImage(received);
var hash2 = HashImage(verified);
var score = ImagePhash.GetCrossCorrelation(hash1, hash2);
var isEqual = score > .999;
if (isEqual)
{
return(Task.FromResult(CompareResult.Equal));
}
var message = $"Score greater than .999. Received score: {score}.";
var result = CompareResult.NotEqual(message);
return(Task.FromResult(result));
}
