Cómo realizar pruebas unitarias de métodos privados en MS Test

A menudo he visto que hay dos escuelas de pensamientos,

1. Los métodos privados deben ser probados.
2. Los métodos privados no deben probarse.

Para poner estas cosas en perspectiva, consideremos una clase de salario del sistema bajo prueba (SUT) como se muestra en la lista a continuación.

namespace Calculator
{
    public class Salary
    {
        public int CalculateSal(int bs, int nwd)
        {
             int ts ;

             if(isValidNwd(nwd))
             {
                 ts= bs*nwd;
             }
             else
             {
                 ts = 1000;
             }
             return ts;
        }

        private bool isValidNwd(int nwd)
        {
            if (nwd > 8)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
    }
}

Un sistema bajo prueba Clase salarial tiene dos funciones:

1. El método CalculateSal es un método público y se necesitan dos parámetros para calcular el salario
2. El método isValidwd es un método privado y toma un parámetro. Esta función devuelve true si el número de días laborables es superior a 8, o de lo contrario devuelve false.
3. El método CalculateSal comprueba primero si el número de días laborables es válido o no mediante el método privado isValidWd.
4. Si el número de días de trabajo es válido, entonces el salario se calcula multiplicando el salario básico y el número de días de trabajo, o bien se fija en $1000.

Ahora tenemos un sistema bajo prueba Clase de salario con dos funciones.

Una opinión es que el método privado no debe probarse por separado. Esto se debe a que el método privado se usa dentro del método público y cuando probamos el comportamiento del método público, también se prueba el comportamiento del método privado.

Otra opinión es que el método privado debe ser probado unitariamente para determinar su propio comportamiento de forma aislada con los otros métodos públicos o privados. Antes de seguir adelante y ver cómo probar un método privado, pensemos un poco sobre si hay otra forma posible de solucionar esto.

Violating Single Responsibility Principle

Actualmente, el sistema bajo prueba de la clase salarial está violando el Principio de Responsabilidad Única porque tiene dos responsabilidades:

1. Para calcular el salario (método público)
2. Para validar el número de días hábiles (método privado)

 

No podemos estar seguros de una buena cobertura de código de la clase SUT Salary a menos que probemos el comportamiento de los días laborables validados de la clase, que es privada por diseño. Una buena opción podría ser la siguiente: al crear la clase de salario, podemos dividir las responsabilidades en dos clases separadas con métodos públicos para calcular el salario y validar los días de trabajo. A continuación, podemos escribir pruebas unitarias para métodos públicos de ambas clases. Veamos cómo hacerlo.

Escritura de pruebas unitarias para métodos privados

Si es de la opinión de que un método privado de la clase SUT debe probarse, tiene dos opciones:

1. Utilice la refactorización, pero esto es un poco complejo;
2. Use la clase PrivateObject de VSTS: ¡esto es simple!

Veamos cómo podemos usar una clase PrivateObject para probar unitariamente un método privado. Para usar una clase de objeto privado, debe:

1. Agregue una referencia de Microsoft.VisualStudio.QualityTools.UnitTestFramework en el proyecto de prueba. Si ha creado un proyecto seleccionando templete de proyecto de prueba unitaria, esta referencia se agregará de forma predeterminada en el proyecto.
2. Add a namespace Microsoft.VisualStudio.TestTools.UnitTesting.

El constructor de PrivateObjectClass toma el tipo como parámetro, por lo que aquí deberá pasar el tipo de la clase SUT Salary y, a continuación, en el objeto de PrivateObjectClass, llame al método invoke para invocar el método privado.

Podemos probar el método privado isValidNwd como se muestra en la lista a continuación:

[TestMethod] 
public void ReturnTrueForValidWorkingDays() {
    PrivateObject objToTestPrivateMethod=new PrivateObject(typeof(Salary));
    bool result=Convert.ToBoolean(objToTestPrivateMethod.Invoke("isValidNwd", 6));
    Assert.AreEqual(result, true);
}

Básicamente, estamos realizando las siguientes tareas:

​         · Creación de un objeto de la clase PrivateObject

​         · Pasar un tipo de clase Salary como parámetro de entrada en el constructor

​         · Uso del método invoke para ejecutar el método privado de la clase SUT Salary

​         · Pasando dos parámetros en el método invoke: el primer parámetro es el nombre del método privado y el segundo parámetro es el argumento que se pasará al método privado mientras se ejecuta

¡Y así es como podemos probar unitariamente un método privado!

Conclusión

En este post aprendimos sobre:

• Si probar un método privado o no
• Cómo probar el método privado mediante la clase PrivateObject

Espero que este post te sea útil, gracias por leer. ¡Feliz codificación!