Hacer el código interno pero disponible para pruebas unitarias de otros proyectos

Ponemos todas nuestras pruebas unitarias en sus propios proyectos. Encontramos que tenemos que hacer ciertas clases públicas en lugar de internas solo para las pruebas unitarias. ¿Hay alguna forma de evitar tener que hacer esto? ¿Cuáles son las implicaciones de la memoria al hacer que las clases sean públicas en lugar de selladas?

Si está utilizando .NET, el atributo de ensamblaje InternalsVisibleTo le permite crear ensamblajes "amigos". Estos son ensamblajes específicos con nombre fuerte que tienen acceso a clases internas y miembros del otro ensamblado.

Tenga en cuenta que esto se debe usar con discreción, ya que acopla firmemente los ensambles involucrados. Un uso común de InternalsVisibleTo es para proyectos de pruebas unitarias. Probablemente no sea una buena opción para usar en los conjuntos de aplicaciones reales, por la razón indicada anteriormente.

Ejemplo:

[assembly: InternalsVisibleTo("NameAssemblyYouWantToPermitAccess")]
namespace NameOfYourNameSpace
{

Si se trata de una clase interna, no se debe utilizar de forma aislada. Por lo tanto, no debería probarlo aparte de probar alguna otra clase que utilice ese objeto internamente.

Del mismo modo que no debería probar los miembros privados de una clase, no debería probar las clases internas de una DLL. Esas clases son detalles de implementación de alguna clase de acceso público y, por lo tanto, deben ejercerse bien a través de otras pruebas unitarias.

La idea es que solo desee probar el comportamiento de una clase porque si prueba los detalles de implementación internos, sus pruebas serán frágiles. Debería poder cambiar los detalles de implementación de cualquier clase sin romper todas sus pruebas.

Si descubre que realmente necesita probar esa clase, es posible que desee volver a examinar por qué esa clase es interna en primer lugar.

para fines de documentación

Alternativamente, puede crear una instancia de clase interna mediante el Type.GetTypemétodo

ejemplo

//IServiceWrapper is public class which is 
//the same assembly with the internal class 
var asm = typeof(IServiceWrapper).Assembly;
//Namespace.ServiceWrapper is internal
var type = asm.GetType("Namespace.ServiceWrapper");
return (IServiceWrapper<T>)Activator
    .CreateInstance(type, new object[1] { /*constructor parameter*/ });

para el tipo genérico hay diferentes procesos como se muestra a continuación:

var asm = typeof(IServiceWrapper).Assembly;
//note the name Namespace.ServiceWrapper`1
//this is for calling Namespace.ServiceWrapper<>
var type = asm.GetType("Namespace.ServiceWrapper`1");
var genType = type.MakeGenericType(new Type[1] { typeof(T) });
return (IServiceWrapper<T>)Activator
     .CreateInstance(genType, new object[1] { /*constructor parameter*/});

Las clases pueden ser públicas y selladas.

Pero no hagas eso.

Puede crear una herramienta para reflexionar sobre las clases internas y emitir una nueva clase que acceda a todo a través de la reflexión. MSTest hace eso.

Editar: Quiero decir, si no quieres incluir -cualquier- cosa de prueba en tu ensamblaje original; Esto también funciona si los miembros son privados.