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)); }