Como refactorizar métodos estáticos

Imagina que encontramos un clase estática con varios métodos estáticos los cuales tienen una cantidad aberrante de parámetros. Queremos eliminarla pero nos damos con que está siendo usada en muchísimas partes ¿que hacemos? ¿Como lo harias vos?.

Para hablar más concretamente veamos uno de esos métodos:

public static void CreateActivityLog(string containerSourceId, string containerId, 

    string action, string sourceId, string instanceId, string docNo, string notes, 

    IFrameworkSecurityContext credentials, BaseSecurityDataContract secContext, 

    string setAction)

Bien, este es quizás uno de los peores escenarios posibles porque para refactorizar necesitamos, antes que nada, contar con un conjunto de test unitarios para asegurarnos de no romper nada. Pero hay un problema con eso, ¿sabes cual es?.

El problema es que los test son dependientes de la firma del método que es precisamente lo eliminar de la faz de la tierra por lo que no nos interesa el refactorizarlo, solo eliminarlo. Además, el método podría (y de hecho seguramente es así) tener dependencias externas como accesos a bases de datos o servicios web etc. y no podemos inyectarle esas dependencias sin agregar más parámetros a la lista.

Pero entonces ¿necesitamos tests o no?. Claro que los necesitamos no son opcionales. Veamos los pasos que necesitamos para hacer lo que queremos:

1.- Crear una clase. En este caso la llamaremos ActivityLog.

// Esta es la clase testeable (proxy class) <<----------------------

public class ActivityLog

{

    private IFrameworkSecurityContext invoker;

    private BaseSecurityDataContract securityContext;

    private DocumentIdentifier container;

    private DocumentIdentifier document;

 

    public ActivityLog(IFrameworkSecurityContext invoker, 

        BaseSecurityDataContract securityContext,

        DocumentIdentifier container, DocumentIdentifier document)

        // acá es donde inyectamos las dependencias <<-----------------------

    {

        this.invoker = invoker;

        this.securityContext = securityContext;

        this.container = container;

        this.document = document;

    }

 

    // Esta es una mejor firma que nos va apermitir refactorizar <<----------

    public void CreateNewLogEntry(

        string documentNumber, string action, string notes, string setAction)

    {

        // llamamos al enjendro mutante

        ManifestHelper.CreateActivityLogDocument(

            container.SourceId.ToString(), container.InstanceId.ToString(), action,

            document.SourceId.ToString(), document.InstanceId.ToString(), 

            documentNumber, notes, invoker, securityContext, setAction);

 

    }

}

2.- Una vez que tenemos esta clase creamos el conjunto de pruebas que necesitamos. En este punto estaremos aún probando el viejo código. Eso es precisamente lo que queremos. Es más, ahora si podríamos inyectarle las dependencias agregándole más parámetros.

3.- Reemplazamos todas las llamadas al método estático con llamadas a este nuevo método. Aún estaremos utilizando el viejo código.

4.- Refactorizar el código del nuevo método creado y eliminar el viejo y mal oliente método estático.

Espero que le sirva a alguien.

Sin categoría

One thought on “Como refactorizar métodos estáticos

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *