CreateAndFake 0.5.69-alpha

Create & Fake

A C# class library in .NET Core designed to make testing a breeze and ultimately change the way developers think about testing. It handles the bulk of the work in creating data to test with, as well as providing mocking and stubbing behavior. Utilizing the tools provided will save a ton of time and make test code far cleaner as well as simpler.

Installation

The library is completely self-contained and requires no dependencies other than .NET Core 2.0. The recommended way to include the library is through a NuGet package reference inside your project under the name "CreateAndFake." Alternatively, binaries can be pulled from the build server linked above under artifacts or compiled manually.

Contributing

If you're looking to contribute, thanks for your interest. Feel free to submit reports for any issues you can find, or request potential features you'd like to see here. I am not looking for code contributions at this time however, so it's unlikely I'll accept any pull requests.

Functionality

The library provides a handful of tools that are both easy to use and customizable should the need arise:

• Randomizer - Creates random instances of any type.
• Randiffer - Creates random variants of objects.
• Duplicator - Creates deep clones of objects.
• Valuer - Compares objects by value.
• Faker - Creates mocks and stubs.
• Asserter - Handles common test scenarios.

One of the benefits of this library is that the tools are logically integrated with each other. For example, the randomizer will use stubs for interfaces that have no known implementations in the code. Or the mocks created by the faker utilize value equality in matching arguments.

Randomization and Equality Example

Imagine you have a class with a ton of data that you've marked with ISerializable. How do you verify that it, you know, actually serializes properly? You'd have to create an instance, populate it with data (which might be no small feat), then serialize it. But wait, are you sure the data actually serialized? You'll need to deserialize it, and probably create equality functions to handle figuring out if your data did in fact make it.

At the end of this you'll have a rather large test that you spent more time setting up than actually testing behavior, and then you have issues. The test has to change every time you change a property on the data class. What happens when a developer forgets to update the test when they added a new property? Potentially, your class now doesn't work correctly and your test is still green. At base, you only know your code works with that specific instance of canned data.

With those considerations in mind, I present to you the solution:

/// <summary>Verifies that class data can make a roundtrip.</summary>
[TestMethod]
public void DataHolder_BinarySerializes()
{
    DataHolder original = Tools.Randomizer.Create<DataHolder>();
    IFormatter formatter = new BinaryFormatter();
    
    using (Stream stream = new MemoryStream())
    {
        formatter.Serialize(stream, original);
        stream.Seek(0, SeekOrigin.Begin);
        
        Tools.Asserter.ValuesEqual(original, formatter.Deserialize(stream));
    }
}

Quick, easy, and most importantly functional. Visit the wiki for more information about these tools as well as others provided.

Mocking Example

The Faker tool provides mocks and stubs in a typical lambda based style with a very methodical structure:

/// <summary>Verifies setup functionality.</summary>
[TestMethod]
public void Setup_ObjectEquality()
{
    object data = new object();
    
    Fake<object> fake = Tools.Faker.Mock<object>();
    fake.Setup(
        d => d.Equals(Arg.Any<object>()),
        Behavior.Set((object o) => { return false; }));
    fake.Setup(
        d => d.Equals(data),
        Behavior.Returns(true, Times.Once));
        
    Tools.Asserter.Is(false, fake.Dummy.Equals(new object()));
    Tools.Asserter.Is(true, fake.Dummy.Equals(data));
    
    fake.Verify(2);
}

Please visit the wiki for more information.