Tests unitaires - Traitement des dépendances

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.