Test unitari - Gestire le dipendenze

Questopotrebbeessere visto come un corollario del Testing hooks callback .

Ilproblema: Vogliotestare una classe che crea unanuovaistanza di una classe My_Notice definita al difuori delplugin (chiamiamola "Main Plugin").

Ilmio unittestnon sanulla di My_Notice perché è definitoin una libreria diterzeparti (un altroplugin,per laprecisione). Pertanto,ho queste opzioni (per quantone so):

1. Stub la classe My_Notice : difficile damantenere
2. Includii filenecessari dalla libreria diterzeparti:potrebbefunzionare,ma sto rendendoi mieitestmenoisolati
3. Stub dinamicamente la classe:non sono sicuro che siapossibile,ma sarebbemolto simile a deridere una classe,tranneperilfatto che dovrebbe anche creare la definizione della stessa,quindi la classe che stotestando saràin grado diistanziareit.

La risposta di @gmazzap sottolinea che dovremmoevitare di creare questo sorta di dipendenze che è qualcosa che sonototalmente d'accordo. E l'idea di creare classi stubnonmi sembrabuona:preferiscoincludereil codice del "Main Plugin",contutte le conseguenze.

Tuttavianon vedo comepossofare altrimenti.

Ecco unesempio del codice che sto cercando ditestare:

  class My_Admin_Notices_Handler {
 funzionepubblica __construct (My_Notices $ admin_notices) {
        $this- > admin_notices=$ admin_notices;
    }

/**
     * Questo sarà agganciato all'azione `activ_plugin`
     *
     * @param string $plugin
     * @parambool $network_wide
     */
 funzionepubblica activ_plugin ($plugin,$network_wide) {
        $this- > add_notice ('plugin','enabled',$plugin);
    }

/**
     * @param string $type
     * @param string $ action
     * @param string $plugin
     */
 funzioneprivata add_notice ($type,$ action,$plugin) {
        $messaggio='';
 if ('attivato'===$ azione) {
 if ('plugin'===$type) {
                $messaggio=__ ('% 1s Somemessageforplugin (s)','my-test-domain');
            }
 if ('theme'===$type) {
                $messaggio=__ ('% 1s Somemessageforthetheme','my-test-domain');
            }
        }
 if ('updated'===$ action & amp; & amp; ('plugin'===$type|| 'theme'===$type)) {
            $messaggio=__ ('% 1s Un altromessaggiopertemi oplugin aggiornati','my-test-domain');
        }

 if ($messaggio) {
            $notice=new My_Notice ($plugin,'wpml-st-string-scan');
            $ avviso- >text=$messaggio;
            $notice- > actions=array (
 new My_Admin_Notice_Action (__ ('Scansiona ora','my-test-domain'),'#'),
 new My_Admin_Notice_Action (__ ('Skip','my-test-domain'),'#',true),
            );
            $this- > admin_notices- > add_notice ($notice);
        }
    }
}
 

Fondamentalmente,questa classe ha unmetodo che verrà agganciato a enabled_plugin . Questometodo crea un'istanza di una classe di "notifica",che verrà archiviata da qualcheparte dall'istanza My_Notices passata al costruttore.

Il costruttore della classe My_Notice riceve due argomenti dibase (un UIDe un "gruppo")e ottiene alcuneproprietàimpostate (ricorda che lo stessoproblema è con My_Admin_Notice_Action classe).

Comepotrei rendere la classe My_Notice una dipendenzainiettata?

Ovviamente,potrei usare un array associativo,chiamare un'azione,che è agganciato dal "Main Plugin"e chetraduce quell'arraynegli argomenti della classe,manonmi sembrapulito.

This might be seen as a corollary of Testing hooks callback.

The issue: I want to test a class which creates a new instance of a My_Notice class defined outside the plugin (let's call it the "Main Plugin").

My unit test knows nothing about My_Notice because it's defined in a third party library (another plugin, to be precise). Therefore, I have these options (as far as I know):

1. Stub the My_Notice class: hard to maintain
2. Include the needed files from the third party library: this may work, but I'm making my tests less isolated
3. Dynamically stub the class: not sure if that's even possible, but it would be very similar to mocking a class, except that it should also create the definition of the same, so the class I'm testing will be able to instantiate it.

The answer from @gmazzap points out that we should avoid creating this sort of dependencies which is something I totally agree. And the idea of creating stub classes doesn't seem good to me: I'd rather include the code of the "Main Plugin", with all the consequences).

However I don't see how can I do otherwise.

Here's an example of the code I'm trying to test:

class My_Admin_Notices_Handler {
    public function __construct( My_Notices $admin_notices ) {
        $this->admin_notices = $admin_notices;
    }

    /**
     * This will be hooked to the `activated_plugin` action
     *
     * @param string $plugin
     * @param bool   $network_wide
     */
    public function activated_plugin( $plugin, $network_wide ) {
        $this->add_notice( 'plugin', 'activated', $plugin );
    }

    /**
     * @param string $type
     * @param string $action
     * @param string $plugin
     */
    private function add_notice( $type, $action, $plugin ) {
        $message = '';
        if ( 'activated' === $action ) {
            if ( 'plugin' === $type ) {
                $message = __( '%1s Some message for plugin(s)', 'my-test-domain' );
            }
            if ( 'theme' === $type ) {
                $message = __( '%1s Some message for the theme', 'my-test-domain' );
            }
        }
        if ( 'updated' === $action && ( 'plugin' === $type || 'theme' === $type ) ) {
            $message = __( '%1s Another message for updated theme or plugin(s)', 'my-test-domain' );
        }

        if ( $message ) {
            $notice          = new My_Notice( $plugin, 'wpml-st-string-scan' );
            $notice->text    = $message;
            $notice->actions = array(
                new My_Admin_Notice_Action( __( 'Scan now', 'my-test-domain' ), '#' ),
                new My_Admin_Notice_Action( __( 'Skip', 'my-test-domain' ), '#', true ),
            );
            $this->admin_notices->add_notice( $notice );
        }
    }
}

Basically, this class has a method which will be hooked to activated_plugin. This method builds an instance of a "notification" class, which will be stored somewhere by the My_Notices instance passed to the constructor.

The constructor of the My_Notice class receives two basic arguments (a UID and a "group") and gets some properties set (mind that the same issue is with the My_Admin_Notice_Action class).

How could I make the My_Notice class an injected dependency?

Of course, I could use an associative array, call some action, which is hooked by the "Main Plugin" and which translates that array in the class's arguments, but it doesn't look clean to me.