static InnerVerifier BuildVerifier(string sourceFile)
{
Guard.AgainstNullOrEmpty(sourceFile, nameof(sourceFile));
var context = TestContext.CurrentContext;
var adapter = context.Test;
var test = (Test)field.GetValue(adapter);
if (SharedVerifySettings.assembly == null)
{
SharedVerifySettings.SetTestAssembly(test.TypeInfo.Assembly);
}
var method = test.Method.MethodInfo;
var name = TestNameBuilder.GetUniqueTestName(Path.GetFileNameWithoutExtension(sourceFile), method, adapter.Arguments);
return(new InnerVerifier(name, sourceFile));
}
public async Task DeriveTestDirectory()
{
string?receivedSourceFile = null;
string?receivedProjectDirectory = null;
SharedVerifySettings.DeriveTestDirectory(
(sourceFile, projectDirectory) =>
{
receivedSourceFile = sourceFile;
receivedProjectDirectory = projectDirectory;
return(Path.GetDirectoryName(sourceFile));
});
await Verifier.Verify("DeriveTestDirectory");
Assert.NotNull(receivedSourceFile);
Assert.True(Directory.Exists(receivedProjectDirectory));
}
public Task ConvertWithCanConvert_Valid()
{
SharedVerifySettings.RegisterFileConverter <CanConvertTarget>(
"txt",
(instance, _) =>
{
var streams = ToStream(instance.Value);
return(new ConversionResult(null, streams));
},
o => o.Value == "Valid");
var target = new CanConvertTarget
{
Value = "Valid"
};
return(Verifier.Verify(target));
}
static VerifyBase()
{
InnerVerifier.Init(
message => new XunitException(message),
input => XunitContext.Context.IntOrNext(input),
input => XunitContext.Context.IntOrNext(input),
input => XunitContext.Context.IntOrNext(input));
SharedVerifySettings.RegisterFileConverter <IRenderedFragment>("html", FragmentToStream.Convert);
SharedVerifySettings.ModifySerialization(settings =>
{
settings.AddExtraSettings(serializerSettings =>
{
var converters = serializerSettings.Converters;
converters.Add(new RenderedFragmentConverter());
});
});
}
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 TypeConversion()
{
SharedVerifySettings.RegisterFileConverter <Bitmap>(
"png",
canConvert: target => Equals(target.RawFormat, ImageFormat.Bmp),
conversion: (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(Verifier.Verify(bitmap, settings));
}
public async Task SettingsArePassed()
{
VerifySettings?fromGlobal = null;
SharedVerifySettings.RegisterComparer(
"SettingsArePassed",
(verifySettings, received, verified) =>
{
fromGlobal = verifySettings;
return(Task.FromResult(new CompareResult(true)));
});
var settings = new VerifySettings();
settings.UseExtension("SettingsArePassed");
await 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 Task Inherited()
{
SharedVerifySettings.RegisterFileConverter <ParentClass>(
"txt",
(instance, _) =>
{
var streams = ToStream(instance.Value);
return(new ConversionResult(null, streams));
});
var target = new InheritedClass
{
Value = "line1"
};
var settings = new VerifySettings();
settings.UseExtension("txt");
return(Verifier.Verify(target, settings));
}
public Task WithInfo()
{
SharedVerifySettings.RegisterFileConverter(
"bmp",
"png",
(stream, _) =>
{
var info = new
{
Property = "Value"
};
var streams = ConvertBmpTpPngStreams(stream);
return(new ConversionResult(info, streams));
});
var settings = new VerifySettings();
settings.UseExtension("bmp");
return(Verify(FileHelpers.OpenRead("sample.bmp"), settings));
}
public Task WithInfo()
{
SharedVerifySettings.RegisterFileConverter <Bitmap>(
"png",
(bitmap1, _) =>
{
var streams = ConvertBmpTpPngStreams(bitmap1);
var info = new
{
Property = "Value"
};
return(new ConversionResult(info, streams));
});
var settings = new VerifySettings();
settings.UseExtension("bmp");
var bitmap = new Bitmap(FileHelpers.OpenRead("sample.bmp"));
return(Verifier.Verify(bitmap, settings));
}
public async Task DeriveTestDirectory()
{
string?receivedTestDirectory = null;
Type? receivedType = null;
string?receivedProjectDirectory = null;
SharedVerifySettings.DeriveTestDirectory(
(type, testDirectory, projectDirectory) =>
{
receivedType = type;
receivedTestDirectory = testDirectory;
receivedProjectDirectory = projectDirectory;
return(testDirectory);
});
await Verify("DeriveTestDirectory");
Assert.NotNull(receivedType);
Assert.True(Directory.Exists(receivedTestDirectory));
Assert.True(Directory.Exists(receivedProjectDirectory));
}
static Tests()
{
BuildServerDetector.Detected = false;
var diffToolPath = Path.GetFullPath(Path.Combine(Environment.CurrentDirectory, "../../../../FakeDiffTool/bin/FakeDiffTool.exe"));
tool = new ResolvedDiffTool(
name: DiffTool.VisualStudio,
exePath: diffToolPath,
buildArguments: (path1, path2) => $"\"{path1}\" \"{path2}\"",
isMdi: false,
supportsAutoRefresh: true,
binaryExtensions: new string[] {});
DiffTools.ResolvedDiffTools = new List <ResolvedDiffTool>
{
tool
};
DiffTools.ExtensionLookup = new Dictionary <string, ResolvedDiffTool>
{
{ "txt", tool },
{ "knownBin", tool },
};
var binPath = AllFiles.Files["jpg"];
AllFiles.Files = new Dictionary <string, EmptyFile>
{
{ "knownBin", binPath },
};
SharedVerifySettings.RegisterFileConverter <TypeToSplit>(
"txt",
(split, settings) => new ConversionResult(
split.Info,
new List <Stream>
{
new MemoryStream(Encoding.UTF8.GetBytes(split.Property1)),
new MemoryStream(Encoding.UTF8.GetBytes(split.Property2))
}));
DiffRunner.MaxInstancesToLaunch(uint.MaxValue);
}
static Task <CompareResult> CompareStrings(string scrubbedInput, string verifiedText, VerifySettings settings)
{
var extension = settings.ExtensionOrTxt();
if (settings.comparer != null)
{
using var stream1 = MemoryStream(scrubbedInput);
using var stream2 = MemoryStream(verifiedText);
return(settings.comparer(settings, stream1, stream2));
}
if (SharedVerifySettings.TryGetComparer(extension, out var comparer))
{
using var stream1 = MemoryStream(scrubbedInput);
using var stream2 = MemoryStream(verifiedText);
return(comparer(settings, stream1, stream2));
}
var result = new CompareResult(string.Equals(verifiedText, scrubbedInput));
return(Task.FromResult(result));
}
public async Task Verify <T>(T target, VerifySettings?settings = null)
{
Guard.AgainstNull(target, nameof(target));
settings = settings.OrDefault();
if (SharedVerifySettings.TryGetConverter(
target,
settings.extension,
out var converter))
{
var converterSettings = GetConverterSettings(settings, converter);
var result = await converter.Conversion(target !, converterSettings);
await VerifyBinary(result.Streams, converterSettings, result.Info);
return;
}
if (target is Stream stream)
{
await VerifyStream(settings, stream);
return;
}
if (typeof(T).ImplementsStreamEnumerable())
{
var enumerable = (IEnumerable)target !;
await VerifyBinary(enumerable.Cast <Stream>(), settings, null);
return;
}
var formatJson = JsonFormatter.AsJson(
target,
settings.serialization.currentSettings,
settings.IsNewLineEscapingDisabled);
var s = formatJson.ToString();
await Verify(formatJson, settings);
}
public async Task Verify <T>(T input, VerifySettings?settings = null)
{
Guard.AgainstNull(input, nameof(input));
settings = settings.OrDefault();
if (SharedVerifySettings.TryGetConverter <T>(
settings.extension,
out var converter))
{
var converterSettings = GetConverterSettings(settings, converter);
var result = await converter.Func(input !, converterSettings);
await VerifyBinary(result.Streams, converterSettings, result.Info);
return;
}
if (input is Stream stream)
{
await VerifyStream(settings, stream);
return;
}
if (typeof(T).ImplementsStreamEnumerable())
{
var enumerable = (IEnumerable)input !;
await VerifyBinary(enumerable.Cast <Stream>(), settings, null);
return;
}
var formatJson = JsonFormatter.AsJson(input, settings.serialization.currentSettings);
if (settings.newLineEscapingDisabled || SharedVerifySettings.newLineEscapingDisabled)
{
formatJson = formatJson.Replace("\\n", "\n").Replace("\\r", "\r");
}
settings.IgnoreTrailingWhitespace();
await Verify(formatJson, settings);
}
public Task WithInfoShouldRespectSettings()
{
SharedVerifySettings.RegisterFileConverter <Bitmap>(
"png",
canConvert: target => Equals(target.RawFormat, ImageFormat.Bmp),
conversion: (bitmap1, _) =>
{
var streams = ConvertBmpTpPngStreams(bitmap1);
var info = new
{
Property = "Value"
};
return(new ConversionResult(info, streams));
});
var settings = new VerifySettings();
settings.UseExtension("bmp");
settings.ModifySerialization(_ => { _.IgnoreMember("Property"); });
var bitmap = new Bitmap(FileHelpers.OpenRead("sample.bmp"));
return(Verifier.Verify(bitmap, settings));
}
public async Task Type()
{
#region RegisterFileConverterType
SharedVerifySettings.RegisterFileConverter <Image>(
toExtension: "png",
#region ConverterCanConvert
canConvert: target => Equals(target.RawFormat, ImageFormat.Tiff),
#endregion
conversion: (image, settings) =>
{
var pages = image.GetFrameCount(FrameDimension.Page);
var streams = new List <Stream>();
for (var index = 0; index < pages; index++)
{
image.SelectActiveFrame(FrameDimension.Page, index);
var page = new MemoryStream();
image.Save(page, ImageFormat.Png);
streams.Add(page);
}
return(new ConversionResult(
info: new
{
image.PixelFormat,
image.Size
},
streams));
});
#endregion
#region FileConverterTypeVerify
await using var stream = File.OpenRead("sample.tif");
await Verify(Image.FromStream(stream));
#endregion
}
public Task DifferingExtensions()
{
SharedVerifySettings.RegisterFileConverter <ClassToSplit3>(
"notTxt",
(classToSplit, _) => throw new Exception());
SharedVerifySettings.RegisterFileConverter <ClassToSplit3>(
"txt",
(instance, _) =>
{
var streams = ToStream(instance.Value);
return(new ConversionResult(null, streams));
});
var target = new ClassToSplit3
{
Value = "line1"
};
var settings = new VerifySettings();
settings.UseExtension("txt");
return(Verify(target, settings));
}
void DontScrubDateTimes()
{
#region DontScrubDateTimes
SharedVerifySettings.ModifySerialization(_ => _.DontScrubDateTimes());
#endregion
}
void ScrubInlineGuids()
{
#region ScrubInlineGuids
SharedVerifySettings.ModifySerialization(_ => _.ScrubInlineGuids());
#endregion
}
void DontIgnoreEmptyCollections()
{
#region DontIgnoreEmptyCollections
SharedVerifySettings.ModifySerialization(_ => _.DontIgnoreEmptyCollections());
#endregion
}
static SerializationTests()
{
SharedVerifySettings.AddExtraDatetimeFormat("F");
SharedVerifySettings.AddExtraDatetimeOffsetFormat("F");
}
public ModuleWeaverTests(ITestOutputHelper output) :
base(output)
{
SharedVerifySettings.UniqueForRuntime();
}
public static void Initialize()
{
SharedVerifySettings.SetTestAssembly(Assembly.GetExecutingAssembly());
}
static ScrubberLevelsSample()
{
// Should be dont at appdomain startup
SharedVerifySettings.AddScrubber(s => s.Replace("One", "A"));
}
void DontIgnoreFalse()
{
#region DontIgnoreFalse
SharedVerifySettings.ModifySerialization(_ => _.DontIgnoreFalse());
#endregion
}
public InnerVerifier(Type testType, string directory, string testName)
{
this.testType = testType;
this.directory = SharedVerifySettings.DeriveDirectory(testType, directory);
this.testName = testName;
}
public static void Setup()
{
SharedVerifySettings.AddScrubber(s => s.Replace("One", "A"));
}
static ComplexParametersSample()
{
//TODO: this should be in the appdomain startup code
SharedVerifySettings.NameForParameter <ComplexData>(_ => _.Value);
}
