Workshop 04

Workshop 04 - Testing

← Home →

Implementing the Data Access Layer

In the UPBLib project add a new class, named MatrixDataAccess, for implementing Matrix comma separated values (csv) file persistence.
In UPBLib, add a folder named "Contracts". In this new folder add a new interface named IMatrixDataAccess: Solution Explorer\ Right click on the Contracts folder\ Add\ New Item\ Interface
In the Matrix class, add an overloaded constructor which expects an array of strings as parameter. The Csv static class is available here: csv file

		
public Matrix(string[] rows) 
{
	var firstRow = Csv.SplitLine(rows[0]);
	var colCount = firstRow.Length;

	Rows = rows.Length;
	Cols = firstRow.Length;
	_matrix = new double[Rows, Cols];

	var rowIndex = 0;
	foreach (var rowString in rows)
	{
		var row = Csv.SplitLine(rowString);
		for (var colIndex = 0; colIndex < colCount; colIndex++)
		{
			_matrix[rowIndex, colIndex] = Csv.ParseDouble(row[colIndex]);
		}
		rowIndex++;
	}
}

Add also a method for exporting the matrix to a csv string:

	
public StringBuilder ToCsv()
{
	var sb = new StringBuilder();
	string line;
	for (int row = 0; row < Rows; row++)
	{
		line = "";
		var separator = "";
		for (int col = 0; col < Cols; col++)
		{
			line += $"{separator}{this[row, col]}";
			separator = ",";
		}
		sb.AppendLine(line);
	}
	return sb;
}

The MatrixDataAccess class will implement the IMatrixDataAccess interface:

	
public interface IMatrixDataAccess
{
	Matrix Read(string file);
	void Write(Matrix matrix, string file);
}

public class MatrixDataAccess : IMatrixDataAccess
{
	public Matrix Read(string file)
	{
		var rows = File.ReadAllLines(file);
		var matrix = new Matrix(rows);
		return matrix;
	}

	public void Write(Matrix matrix, string file) 
	{
		var sbCsv = matrix.ToCsv();
		File.WriteAllText(file, sbCsv.ToString());
	}
}

A loosely coupling (vs strongly coupling) between Matrix and MatrixDataAccess classes will be considered:

	
public Matrix(double[,] array)
{
	LoadArray(array);
}

protected void LoadArray(double[,] array)
{
	_matrix = array;
	Rows = _matrix.GetLength(0);
	Cols = _matrix.GetLength(1);
}

protected IMatrixDataAccess _dataAccess;
public IMatrixDataAccess DataAccess
{
	get { return _dataAccess ?? (_dataAccess = new MatrixDataAccess()); }
	set { _dataAccess = value; }
}

public void Read(string file)
{
	var matrix = DataAccess.Read(file);
	LoadArray(matrix._matrix);   
}

public void Write(string file)
{
	DataAccess.Write(this, file);
}

Automatic Testing

When testing a gear, one would first test each component wheel => unit testing
Only after confirming each wheel has no defect, one could consider testing the interaction between wheels => integration testing

Unit Testing

As suggested, we intend to test each class in isolation of any dependency.
As Matrix and MatrixDataAccess are loosely coupled, it is possible to use polymorphism for injecting a data access "mock" into the Matrix class.
Add a new class, named MatrixDataAccessMock : IMatrixDataAccess into the UPBTest test project.

	
internal class MatrixDataAccessMock : IMatrixDataAccess
{
	public Matrix Read(string file)
	{
		var array = new double[,] { };
		switch (file)
		{
			case "m1":
				array = new double[,]
				{
					{ 1, 2, 3 },
					{ 2, 3, 4 }
				};
				break;
			case "m2":
				array = new double[,]
				{
					{ 1, 2},
					{ 2, 3},
					{ 3, 4}
				};
				break;
		}
		return new Matrix(array);
	}

	public void Write(Matrix matrix, string file)
	{
	}
}

In order to be able to compare 2 Matrix instances (contained data, not addresses), override the Matrix Equals virtual method:

public override bool Equals(object? obj)
{
	var other = obj as Matrix;
	if (other == null) return false;
	if (this == other) return true; // pointing to the same address?
	if ((this.Rows != other.Rows) || (this.Cols != other.Cols)) return false;

	for (int row = 0; row < Rows; row++)
	{
		for (int col = 0; col < Cols; col++)
		{
			if (this[row, col] != other[row, col])
			{
				return false;
			}
		}
	}

	return true;
}

It is the time to write our first unit test into the MatrixTest test class. Notice the [TestClass] and [TestMethod] attributes used!

[TestClass]
public class MatrixTest
{
	[TestMethod]
	public void Product_ValidMatrices_Success()
	{
		var dataAccessMock = new MatrixDataAccessMock();

		var m1 = new Matrix();
		m1.DataAccess = dataAccessMock;
		m1.Read("m1");

		var m2 = new Matrix();
		m2.DataAccess = dataAccessMock;
		m2.Read("m2");

		var m = m1 * m2;

		var array = new double[,]
		{
			{ 14, 20 },
			{ 20, 29 }
		};
		var expectedResult = new Matrix(array);

		// AreEqual is calling the Equals overriden version	
		Assert.AreEqual(m, expectedResult);
	}
}

For checking the behaviour in case incorrect input parameters are provided, one could consider implementing negative tests:

[TestMethod]
public void Product_InvalidSizeMatrices_ThrowArgumentException()
{
	var dataAccessMock = new MatrixDataAccessMock();
	var m1 = new Matrix();
	m1.DataAccess = dataAccessMock;
	m1.Read("m1");

	var m2 = new Matrix();
	m2.DataAccess = dataAccessMock;
	m2.Read("m1");

	Assert.ThrowsException<ArgumentException>(() => m1 * m2);
}

The test methods are often sharing common initialization actions. In order to increase code reusability, one could implement a test initialization method => a function decorated with the TestInitialize attribute.
Notice that test initialization will be executed before calling each test method and not once per class.

private MatrixDataAccessMock? _dataAccessMock;

[TestInitialize]
public void Initialize()
{
	_dataAccessMock = new MatrixDataAccessMock();
}

Integration Testing

For implementing integration tests, one could use the MatrixDataAccess class (not the Mock) together with a corresponding set of testing files.

References:

Migration of hyper-fractal analysis from visual basic 6 to C# .Net

← Home →