propiedades - llamar una clase en c#

¿Puedo hacer que Moq agregue atributos a la clase simulada?

Question

Estoy escribiendo una interfaz de línea de comandos para mi proyecto. El usuario ingresa "create project foo", y encuentra que el controlador es responsable de "project" y luego invoca el método Create , pasando "foo" como primer argumento.

Se basa en gran medida en los atributos y la reflexión: el controlador se ve así:

[ControllerFor("project")]
class ProjectController
{
    [ControllerAction("create")]
    public object Create(string projectName) { /* ... */ }
}

Me gustaría utilizar Moq en las pruebas unitarias para el analizador, algo como esto:

Mock<IProjectsController> controller = new Mock<IProjectsController>();
controller.Expect(f => f.Create("foo"));

parser.Register(controller.Object);
parser.Execute("create project foo");

controller.VerifyAll();

Agregar los atributos a la interfaz no parece funcionar, no son heredados por las clases derivadas.

¿Puedo hacer que Moq agregue atributos a la clase que se está burlando?

Answer 1

Actualización: me acabo de dar cuenta de que realmente puede agregar atributos a un tipo existente mediante el uso de TypeDescriptor.AddAttributes , que se puede ejecutar en una instancia o en un tipo:

Mock<IRepository> repositoryMock = new Mock<IRepository>();

CustomAttribute attribute = new CustomAttribute();

// option #1: to the instance
TypeDescriptor.AddAttributes(repositoryMock.Object, attribute );

// option #2: to the generated type
TypeDescriptor.AddAttributes(repositoryMock.Object.GetType(), attributes);

Si lo necesita, AddAttribute devuelve un TypeDescriptorProvider que se puede pasar a TypeDescriptor.RemoveProvider para eliminar los atributos posteriormente.

Tenga en cuenta que Attribute.GetCustomAttributes no encontrará los atributos agregados en el tiempo de ejecución de esta manera. En su lugar, use TypeDescriptor.GetAttributes .

Respuesta original

No creo que Moq (ni ningún otro marco burlón para el caso) admita atributos personalizados. Sé que Castle Proxy (el marco comúnmente utilizado para crear la clase) lo admite, pero no habría forma de acceder a él a través de Moq.

Su mejor opción es abstraer su método de carga de Atributos en una interfaz (que acepte el tipo y el tipo de Atributo) y luego simular eso.

Editar: por ejemplo:

public interface IAttributeStrategy
{
    Attribute[] GetAttributes(Type owner, Type attributeType, bool inherit);
    Attribute[] GetAttributes(Type owner, bool inherit);
}

public class DefaultAttributeStrategy : IAttributeStrategy
{
    public Attribute[] GetAttributes(Type owner, Type attributeType, bool inherit)
    {
        return owner.GetCustomAttributes(attributeType, inherit);
    }

    public Attribute[] GetAttributes(Type owner, bool inherit)
    {
        return owner.GetCustomAttributes(inherit);
    }
}

La clase que necesita los atributos usa una instancia de IAttributeStrategy (ya sea a través de un contenedor IoC o haciendo que pase opcionalmente al constructor). Por lo general, será una DefaultAttributeStrategy, pero ahora puede simular IAttributeStrategy para anular la salida.

Puede sonar intrincado, pero agregar una capa de abstracción es mucho más fácil que tratar de simular en realidad los Atributos.