ONE PIECE HACKING

Ngiler SH3LL 360
: / home / tbf / tbf.ro / vendor / mockery / mockery / docs / cookbook /

Information Server
MySQL : OFF Perl : OFF CURL : ON WGET : OFF PKEXEC : OFF

Directive	Local Value
IP Address	89.40.16.97
System	Linux server.atelieruldeit.ro 3.10.0-1160.el7.x86_64 #1 SMP Mon Oct 19 16:18:59 UTC 2020 x86_64
User	tbf
PHP Version	7.3.33
Software	Apache
Doc root	Writable

Edit File : class_constants.rst \| Size : 4.57 KB
.. index:: single: Cookbook; Class Constants Class Constants =============== When creating a test double for a class, Mockery does not create stubs out of any class constants defined in the class we are mocking. Sometimes though, the non-existence of these class constants, setup of the test, and the application code itself, it can lead to undesired behavior, and even a PHP error: ``PHP Fatal error: Uncaught Error: Undefined class constant 'FOO' in ...``` While supporting class constants in Mockery would be possible, it does require an awful lot of work, for a small number of use cases. Named Mocks ----------- We can, however, deal with these constants in a way supported by Mockery - by using :ref:`creating-test-doubles-named-mocks`. A named mock is a test double that has a name of the class we want to mock, but under it is a stubbed out class that mimics the real class with canned responses. Lets look at the following made up, but not impossible scenario: .. code-block:: php class Fetcher { const SUCCESS = 0; const FAILURE = 1; public static function fetch() { // Fetcher gets something for us from somewhere... return self::SUCCESS; } } class MyClass { public function doFetching() { $response = Fetcher::fetch(); if ($response == Fetcher::SUCCESS) { echo "Thanks!" . PHP_EOL; } else { echo "Try again!" . PHP_EOL; } } } Our ``MyClass`` calls a ``Fetcher`` that fetches some resource from somewhere - maybe it downloads a file from a remote web service. Our ``MyClass`` prints out a response message depending on the response from the ``Fetcher::fetch()`` call. When testing ``MyClass`` we don't really want ``Fetcher`` to go and download random stuff from the internet every time we run our test suite. So we mock it out: .. code-block:: php // Using alias: because fetch is called statically! \Mockery::mock('alias:Fetcher') ->shouldReceive('fetch') ->andReturn(0); $myClass = new MyClass(); $myClass->doFetching(); If we run this, our test will error out with a nasty ``PHP Fatal error: Uncaught Error: Undefined class constant 'SUCCESS' in ..``. Here's how a ``namedMock()`` can help us in a situation like this. We create a stub for the ``Fetcher`` class, stubbing out the class constants, and then use ``namedMock()`` to create a mock named ``Fetcher`` based on our stub: .. code-block:: php class FetcherStub { const SUCCESS = 0; const FAILURE = 1; } \Mockery::namedMock('Fetcher', 'FetcherStub') ->shouldReceive('fetch') ->andReturn(0); $myClass = new MyClass(); $myClass->doFetching(); This works because under the hood, Mockery creates a class called ``Fetcher`` that extends ``FetcherStub``. The same approach will work even if ``Fetcher::fetch()`` is not a static dependency: .. code-block:: php class Fetcher { const SUCCESS = 0; const FAILURE = 1; public function fetch() { // Fetcher gets something for us from somewhere... return self::SUCCESS; } } class MyClass { public function doFetching($fetcher) { $response = $fetcher->fetch(); if ($response == Fetcher::SUCCESS) { echo "Thanks!" . PHP_EOL; } else { echo "Try again!" . PHP_EOL; } } } And the test will have something like this: .. code-block:: php class FetcherStub { const SUCCESS = 0; const FAILURE = 1; } $mock = \Mockery::mock('Fetcher', 'FetcherStub') $mock->shouldReceive('fetch') ->andReturn(0); $myClass = new MyClass(); $myClass->doFetching($mock); Constants Map ------------- Another way of mocking class constants can be with the use of the constants map configuration. Given a class with constants: .. code-block:: php class Fetcher { const SUCCESS = 0; const FAILURE = 1; public function fetch() { // Fetcher gets something for us from somewhere... return self::SUCCESS; } } It can be mocked with: .. code-block:: php \Mockery::getConfiguration()->setConstantsMap([ 'Fetcher' => [ 'SUCCESS' => 'success', 'FAILURE' => 'fail', ] ]); $mock = \Mockery::mock('Fetcher'); var_dump($mock::SUCCESS); // (string) 'success' var_dump($mock::FAILURE); // (string) 'fail' Back

Edit File : class_constants.rst | Size : 4.57 KB

.. index::
    single: Cookbook; Class Constants

Class Constants
===============

When creating a test double for a class, Mockery does not create stubs out of
any class constants defined in the class we are mocking. Sometimes though, the
non-existence of these class constants, setup of the test, and the application
code itself, it can lead to undesired behavior, and even a PHP error:
``PHP Fatal error:  Uncaught Error: Undefined class constant 'FOO' in ...```

While supporting class constants in Mockery would be possible, it does require
an awful lot of work, for a small number of use cases.

Named Mocks
-----------

We can, however, deal with these constants in a way supported by Mockery - by
using :ref:`creating-test-doubles-named-mocks`.

A named mock is a test double that has a name of the class we want to mock, but
under it is a stubbed out class that mimics the real class with canned responses.

Lets look at the following made up, but not impossible scenario:

.. code-block:: php

class Fetcher
    {
        const SUCCESS = 0;
        const FAILURE = 1;

public static function fetch()
        {
            // Fetcher gets something for us from somewhere...
            return self::SUCCESS;
        }
    }

class MyClass
    {
        public function doFetching()
        {
            $response = Fetcher::fetch();

if ($response == Fetcher::SUCCESS) {
                echo "Thanks!" . PHP_EOL;
            } else {
                echo "Try again!" . PHP_EOL;
            }
        }
    }

Our ``MyClass`` calls a ``Fetcher`` that fetches some resource from somewhere -
maybe it downloads a file from a remote web service. Our ``MyClass`` prints out
a response message depending on the response from the ``Fetcher::fetch()`` call.

When testing ``MyClass`` we don't really want ``Fetcher`` to go and download
random stuff from the internet every time we run our test suite. So we mock it
out:

.. code-block:: php

// Using alias: because fetch is called statically!
    \Mockery::mock('alias:Fetcher')
        ->shouldReceive('fetch')
        ->andReturn(0);

$myClass = new MyClass();
    $myClass->doFetching();

If we run this, our test will error out with a nasty
``PHP Fatal error:  Uncaught Error: Undefined class constant 'SUCCESS' in ..``.

Here's how a ``namedMock()`` can help us in a situation like this.

We create a stub for the ``Fetcher`` class, stubbing out the class constants,
and then use ``namedMock()`` to create a mock named ``Fetcher`` based on our
stub:

.. code-block:: php

class FetcherStub
    {
        const SUCCESS = 0;
        const FAILURE = 1;
    }

\Mockery::namedMock('Fetcher', 'FetcherStub')
        ->shouldReceive('fetch')
        ->andReturn(0);

$myClass = new MyClass();
    $myClass->doFetching();

This works because under the hood, Mockery creates a class called ``Fetcher``
that extends ``FetcherStub``.

The same approach will work even if ``Fetcher::fetch()`` is not a static
dependency:

.. code-block:: php

class Fetcher
    {
        const SUCCESS = 0;
        const FAILURE = 1;

public function fetch()
        {
            // Fetcher gets something for us from somewhere...
            return self::SUCCESS;
        }
    }

class MyClass
    {
        public function doFetching($fetcher)
        {
            $response = $fetcher->fetch();

if ($response == Fetcher::SUCCESS) {
                echo "Thanks!" . PHP_EOL;
            } else {
                echo "Try again!" . PHP_EOL;
            }
        }
    }

And the test will have something like this:

.. code-block:: php

class FetcherStub
    {
        const SUCCESS = 0;
        const FAILURE = 1;
    }

$mock = \Mockery::mock('Fetcher', 'FetcherStub')
    $mock->shouldReceive('fetch')
        ->andReturn(0);

$myClass = new MyClass();
    $myClass->doFetching($mock);

Constants Map
-------------

Another way of mocking class constants can be with the use of the constants map configuration.

Given a class with constants:

.. code-block:: php

class Fetcher
    {
        const SUCCESS = 0;
        const FAILURE = 1;

public function fetch()
        {
            // Fetcher gets something for us from somewhere...
            return self::SUCCESS;
        }
    }

It can be mocked with:

.. code-block:: php

\Mockery::getConfiguration()->setConstantsMap([
        'Fetcher' => [
            'SUCCESS' => 'success',
            'FAILURE' => 'fail',
        ]
    ]);

$mock = \Mockery::mock('Fetcher');
    var_dump($mock::SUCCESS); // (string) 'success'
    var_dump($mock::FAILURE); // (string) 'fail'

Back