Declare Theory DisplayName

[JDCain]

I'm looking for a way to simplify Theory DisplayNames which exits both with Discovery & Execution processes. This is so that people can find and debug specific tests while in Visual Studio. Specifically I want to assign each a Test Case Id.

The first way I came across was to use IXunitSerializable in order to override the serialization process but due to use of fixtures and ITestOutputHelper I get the error: xUnit3001 Class must have a public parameterless constructor to support Xunit.Abstractions.IXunitSerializable.

I also tried overriding ToString on a complex type and this works when running the tests, but not for discovery / displaying the names within the test runner.

[JDCain]

I did some more research since yesterday and realized I did not understand how IXunitSerializable was to be used. Working from some other info on stack overflow I think I have what I want working. Any suggestions on how to simplify it would be appreciated.

    public class TheoryNameTests
    {
        [SkippableTheory]
        [Trait("xUnit", "ForTestRunner")]
        [MemberData(nameof(ComplexTheoryData))]
        public void SkippableComplexTheoryTest_TestRunner(int id, TheoryWrapper<Test> test)
        {
            Assert.Equal("pass", test.Object.TestData);
            //throw new SkipTestException(test.Name);
        }
        public static IEnumerable<object[]> ComplexTheoryData
            {
                get
                {
                    return new List<object[]>
                    {
                        new object[] {0, new TheoryWrapper<Test>("Pass0", new Test{ TestData = "pass" })},
                        new object[] {1, new TheoryWrapper<Test>("Pass1", new Test{ TestData = "pass" })},
                        new object[] {2, new TheoryWrapper<Test>("Fail", new Test{ TestData = "fail" })},
                    };
                }
            }
    }

    public class Test
    {
        public string TestData { get; set; }
    }

    public class TheoryWrapper<T> : IXunitSerializable
    {
        public TheoryWrapper(string label, T @object)
        {
            Name = label;
            Object = @object;
        }
        public TheoryWrapper()
        {

        }
        public string Name { get; set; }
        public T Object { get; set; }

        public void Deserialize(IXunitSerializationInfo info)
        {
            Name = info.GetValue<string>("Label");
            Object = JsonConvert.DeserializeObject<T>(info.GetValue<string>("objValue"));
        }

        public void Serialize(IXunitSerializationInfo info)
        {
            info.AddValue("Label", Name, typeof(string));
            var json = JsonConvert.SerializeObject(Object);
            info.AddValue("objValue", json);
        }

        public override string ToString()
        {
            return Name;
        }
    }

Discovers and runs in VS and also correctly restores the IXunitSerializable data.

[bradwilson]

Yes, you have discovered the correct way to do this.

Serialization of theory data is what allows us to be able to display each data row as an individual test. We support serialization of the built-in types ourselves, but we rely on you to implement for custom types. And as you noticed, ToString is used when displaying the value in the parameter list, so you see your simplified version instead of our pseudo C#/JSON-looking thing. 😄

I think you have the optimal solution right now! 👍🏼

[gpiccin]

After many tries, I've used the same strategy of serializing complex objects as a JSON. How said @bradwilson I think that you propose here an excellent solution to turn easy the IXunitSerializable implementation.

Good job!

[Camble]

This solution works beautifully with both NCrunch and Visual Studio Test Explorer. Thank you!

[atruskie]

Thanks for the tip!

I used JsonConvert.PopulateObject to deserialize into current instance. This let me avoid the wrapper objects (which is ideal for me).

public class FixtureModel : IXunitSerializable
{
        // <snip>

        public override string ToString()
        {
            return this.Name + " (" + this.FixturePath + ")";
        }

        public void Deserialize(IXunitSerializationInfo info)
        {
            JsonConvert.PopulateObject(info.GetValue<string>("Value"), this, JsonSerializerSettings);
        }

        public void Serialize(IXunitSerializationInfo info)
        {
            var json = JsonConvert.SerializeObject(this, JsonSerializerSettings);
            info.AddValue("Value", json);
        }
}