EDennis.NetCoreTestingUtilities 1.0.0.1

Overview

This package utilizes the Newtonsoft JSON library to provide methods that make testing of objects and object collections a little easier. The package is intended to be used in Test projects only, as it uses reflection extensively and is not performance-optimized.

Object Extension Methods

The following extension methods for objects are provided:

bool IsSame(T obj)

This method returns true if the provided object variable and the current object variable (this) refer to the same object in memory. The method compares hashes and property values. Example:

[Test]
public void TestSameObjectInMemory() {
    Person p1 = new Person("Bob", "Jones");
    Person p2 = p1; //assign p2 to point to p1 (same object in memory)
    Assert.True(p1.IsSame(p2)); 
}

bool IsEqual(T obj)

This method returns true if the provided object variable and the current object variable (this) have the same property values. NOTE: this is a deep comparison. Example:

[Test]
public void TestEqualObjects() {
    Person p1 = new Person("Bob", "Jones");
    Person p2 = new Person("Bob", "Jones");
    Assert.False(p1.IsSame(p2));
    Assert.True(p1.IsEqual(p2));
}

bool IsEqual(T obj, string[] pathsToIgnore)

This method returns true if the provided object variable and the current object variable (this) have the same property values, ignoring all properties at the provided JSON paths. Example:

[Test]
public void TestEqualObjectsIgnoringSelectedProperties() {
    Person p1 = new Person(1, "Bob", "Jones");
    Person p2 = new Person(2, "Bob", "Jones");
    Assert.False(p1.IsEqual(p2));
    Assert.True(p1.IsEqual(p2, new string[] { "ID" })); //ignore ID
}

string ToJsonString()

This method serializes an object to a JSON string. Example:

[Test]
public void TestToJsonString() {
    string expectedJson =
        @"{
         ""ID"": 0,
         ""FirstName"": ""David"",
         ""LastName"": ""Parks""
        }";
    expectedJson = JToken.Parse(expectedJson).ToString(Formatting.Indented);
    Person p1 = new Person("David", "Parks");
    string actualJson = p1.ToJsonString();
    Assert.AreEqual(expectedJson, actualJson);
}

T FromJsonString<T>(string json)

This method creates a new object of type T by deserializing the provided JSON string. When called from an object constructor, this method provides a convenient way to load an object with properties. Example:

[Test]
public void TestFromJsonString() {
    string json =
        @"{
         ""FirstName"": ""David"",
         ""LastName"": ""Parks""
        }";
    var p1 = new Person().FromJsonString(json);
    Person p2 = new Person("David", "Parks");
    Assert.True(p1.IsEqual(p2));
}

T FromJsonPath<T>(JToken jtoken, string jsonPath)

This method creates a new object of type T by deserializing a JSON object or array at the provided path in the provided JToken object. When called from an object constructor, this method provides a convenient way to load an object with properties. Example:

[Test]
public void TestFromJsonPath1() {
    string json =
       @"{
         ""FirstName"": ""David"",
         ""LastName"": ""Parks"",
         ""Contact"": {
             ""FirstName"": ""Jill"",
             ""LastName"": ""Parks""
            }
        }";
    var jtoken = JToken.Parse(json);
    var p1 = new Person().FromJsonPath(jtoken, "Contact");
    Person p2 = new Person("Jill", "Parks");
    Assert.True(p1.IsEqual(p2));
}

T FromJsonPath<T>(string filePath, string objectPath)

This method creates a new object of type T by deserializing a JSON object or array in the provided JSON file at the provided path. When called from an object constructor, this method provides a convenient way to load an object with properties. NOTE: you can use "" or "/" instead of "." in the objectPath. Example:

[Test]
public void TestFromJsonPath2() {
    var p1 = new Person().FromJsonPath(@"DavidParks.json", "Contact");
    Person p2 = new Person("Jill", "Parks");
    Assert.True(p1.IsEqual(p2));
}

T FromJsonPath<T>(string jsonFileObjectPath)

This method is equivalent to the above method, but it combines the filePath and objectPath into a single expression. Note that you can use a backslash or forward slash instead of period in the objectPath. Example:

[Test]
public void TestFromJsonPath3() {
    var p1 = new Person().FromJsonPath(@"DavidParks.json\Contact");
    Person p2 = new Person("Jill", "Parks");
    Assert.True(p1.IsEqual(p2));
}

JsonAssert Class

A JsonAssert Class is provided with an static, overloaded ExecuteTest method that reads in a test case from a JSON file in a specific test folder/subfolder and executes the test case. This method makes numerous assumptions about the format of the JSON file and its location. When these assumptions are met, the C# code needed to invoke the method from a test class is minimal. Here are the assumptions:

• The method under test is an instance method, not a static method.
• The JSON file consists of a single JSON object whose property names (except for one) exactly match the parameter names for the method under test.
• The expected return value for the test case is represented by a "returns" property in the JSON file.
• All data within the JSON file reflect properly serialized values, which are parseable by Json.NET.

static void ExecuteTest<T>(T obj, string testCase)

This method accepts an instantiated object (obj) and a file name excluding folder and extension(testCase) as parameters. It throws a JsonAssertException if the test case fails. This method makes some additional assumptions:

• The JSON test case must be placed in a subfolder whose name is the same as the method to be tested.
• The method subfolder must be placed in a top-level folder whose name is the same as the name of the class to be tested.
• The JSON file has a .json extension.

Example:

{
  "persons": [
    {
      "FirstName": "David",
      "LastName": "Parks",
      "DateOfBirth": "1987-06-29"
    },
    {
      "FirstName": "Johnny",
      "LastName": "Sandoval",
      "DateOfBirth": "2014-12-06"
    }
  ],
  "returns":     {
      "FirstName": "Johnny",
      "LastName": "Sandoval",
      "DateOfBirth": "2014-12-06"
    }
}

/// <summary>
/// Assumes the PersonManager class has an instance method
/// called Youngest and that for each of the provided testCase 
/// values in the range (1-2), there is a properly formatted
/// JSON file residing in the right folder and subfolder
/// (e.g., "PersonManager\Youngest\01.json")
/// </summary>
/// <param name="testCase">The name of the test case</param>
[Test]
public void Youngest([Range(1, 2)] int testCase) {
    JsonAssert.ExecuteTest(new PersonManager(), testCase.ToString("D2"));
}

static void ExecuteTest<T>(T obj, string filePath, string methodName, string testCase)

This method is the same as the previous method, but it allows the caller to explicitly set the file path and the name of the method under test.