CallCenter::createUnexpectedCallException() - Code Metrics - Inspection of "CallCenter: improved formatting for unexpected met..." - phpspec/prophecy - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#408)

unknown

created 2018-06-27 17:38 UTC

CallCenter::createUnexpectedCallException() B

↳ Parent: CallCenter

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	55
rs	8.9818
c	0
b	0
f	0
cc	1
nc	1
nop	3

How to fix Long Method

<?php

/*
 * This file is part of the Prophecy.
 * (c) Konstantin Kudryashov <[email protected]>
 *     Marcello Duarte <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Prophecy\Call;

use Prophecy\Exception\Prophecy\MethodProphecyException;
use Prophecy\Prophecy\MethodProphecy;
use Prophecy\Prophecy\ObjectProphecy;
use Prophecy\Argument\ArgumentsWildcard;
use Prophecy\Util\StringUtil;
use Prophecy\Exception\Call\UnexpectedCallException;

/**
 * Calls receiver & manager.
 *
 * @author Konstantin Kudryashov <[email protected]>
 */
class CallCenter
{
    private $util;

    /**
     * @var Call[]
     */
    private $recordedCalls = array();

    /**
     * Initializes call center.
     *
     * @param StringUtil $util
     */
    public function __construct(StringUtil $util = null)
    {
        $this->util = $util ?: new StringUtil;
    }

    /**
     * Makes and records specific method call for object prophecy.
     *
     * @param ObjectProphecy $prophecy
     * @param string         $methodName
     * @param array          $arguments
     *
     * @return mixed Returns null if no promise for prophecy found or promise return value.
     *
     * @throws \Prophecy\Exception\Call\UnexpectedCallException If no appropriate method prophecy found
     */
    public function makeCall(ObjectProphecy $prophecy, $methodName, array $arguments)
    {
        // For efficiency exclude 'args' from the generated backtrace
        if (PHP_VERSION_ID >= 50400) {
            // Limit backtrace to last 3 calls as we don't use the rest
            // Limit argument was introduced in PHP 5.4.0
            $backtrace = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 3);
        } elseif (defined('DEBUG_BACKTRACE_IGNORE_ARGS')) {
            // DEBUG_BACKTRACE_IGNORE_ARGS was introduced in PHP 5.3.6
            $backtrace = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS);
        } else {
            $backtrace = debug_backtrace();
        }

        $file = $line = null;
        if (isset($backtrace[2]) && isset($backtrace[2]['file'])) {
            $file = $backtrace[2]['file'];
            $line = $backtrace[2]['line'];
        }

        // If no method prophecies defined, then it's a dummy, so we'll just return null
        if ('__destruct' === $methodName || 0 == count($prophecy->getMethodProphecies())) {
            $this->recordedCalls[] = new Call($methodName, $arguments, null, null, $file, $line);

            return null;
        }

        // There are method prophecies, so it's a fake/stub. Searching prophecy for this call
        $matches = array();
        foreach ($prophecy->getMethodProphecies($methodName) as $methodProphecy) {
            if (0 < $score = $methodProphecy->getArgumentsWildcard()->scoreArguments($arguments)) {
                $matches[] = array($score, $methodProphecy);
            }
        }

        // If fake/stub doesn't have method prophecy for this call - throw exception
        if (!count($matches)) {
            throw $this->createUnexpectedCallException($prophecy, $methodName, $arguments);
        }

        // Sort matches by their score value
        @usort($matches, function ($match1, $match2) { return $match2[0] - $match1[0]; });
// For example instead of
@mkdir($dir);

// Better use
if (@mkdir($dir) === false) {
    throw new \RuntimeException('The directory '.$dir.' could not be created.');
}

        // If Highest rated method prophecy has a promise - execute it or return null instead
        $methodProphecy = $matches[0][1];
        $returnValue = null;
        $exception   = null;
        if ($promise = $methodProphecy->getPromise()) {
            try {
                $returnValue = $promise->execute($arguments, $prophecy, $methodProphecy);
            } catch (\Exception $e) {
                $exception = $e;
            }
        }

        if ($methodProphecy->hasReturnVoid() && $returnValue !== null) {
            throw new MethodProphecyException(
                "The method \"$methodName\" has a void return type, but the promise returned a value",
                $methodProphecy
            );
        }

        $this->recordedCalls[] = new Call(
            $methodName, $arguments, $returnValue, $exception, $file, $line
        );

        if (null !== $exception) {
            throw $exception;
        }

        return $returnValue;
    }

    /**
     * Searches for calls by method name & arguments wildcard.
     *
     * @param string            $methodName
     * @param ArgumentsWildcard $wildcard
     *
     * @return Call[]
     */
    public function findCalls($methodName, ArgumentsWildcard $wildcard)
    {
        return array_values(
            array_filter($this->recordedCalls, function (Call $call) use ($methodName, $wildcard) {
                return $methodName === $call->getMethodName()
                    && 0 < $wildcard->scoreArguments($call->getArguments())
                ;
            })
        );
    }

    private function createUnexpectedCallException(ObjectProphecy $prophecy, $methodName,
                                                   array $arguments)
    {
        $classname = get_class($prophecy->reveal());
        $indentationLength = 8; // looks good
        $argstring = implode(
            ",\n",
            $this->indentArguments(
                array_map(array($this->util, 'stringify'), $arguments),
                $indentationLength
            )
        );

        $expected = implode(
            "\n",
            array_map(
                function (MethodProphecy $methodProphecy) use ($indentationLength) {
                    return sprintf(
                        "  - %s(\n".
                        "%s\n".
                        "    )",
                        $methodProphecy->getMethodName(),
                        implode(
                            ",\n",
                            $this->indentArguments(
                                array_map(
                                    function ($token) {
                                        return (string) $token;
                                    },
                                    $methodProphecy->getArgumentsWildcard()->getTokens()
                                ),
                                $indentationLength
                            )
                        )
                    );
                },
                call_user_func_array('array_merge', $prophecy->getMethodProphecies())
            )
        );

        return new UnexpectedCallException(
            sprintf(
                "Unexpected method call on %s:\n".
                "  - %s(\n".
                "%s\n".
                "    )\n".
                "expected calls were:\n".
                "%s",

                $classname, $methodName, $argstring, $expected
            ),
            $prophecy, $methodName, $arguments

        );
    }

    private function indentArguments(array $arguments, $indentationLength)
    {
        return preg_replace_callback(
            '/^/m',
            function () use ($indentationLength) {
                return str_repeat(' ', $indentationLength);
            },
            $arguments
        );
    }
}


1			<?php
2
3			/*
4			* This file is part of the Prophecy.
5			* (c) Konstantin Kudryashov <[email protected]>
6			* Marcello Duarte <[email protected]>
7			*
8			* For the full copyright and license information, please view the LICENSE
9			* file that was distributed with this source code.
10			*/
11
12			namespace Prophecy\Call;
13
14			use Prophecy\Exception\Prophecy\MethodProphecyException;
15			use Prophecy\Prophecy\MethodProphecy;
16			use Prophecy\Prophecy\ObjectProphecy;
17			use Prophecy\Argument\ArgumentsWildcard;
18			use Prophecy\Util\StringUtil;
19			use Prophecy\Exception\Call\UnexpectedCallException;
20
21			/**
22			* Calls receiver & manager.
23			*
24			* @author Konstantin Kudryashov <[email protected]>
25			*/
26			class CallCenter
27			{
28			private $util;
29
30			/**
31			* @var Call[]
32			*/
33			private $recordedCalls = array();
34
35			/**
36			* Initializes call center.
37			*
38			* @param StringUtil $util
39			*/
40			public function __construct(StringUtil $util = null)
41			{
42			$this->util = $util ?: new StringUtil;
43			}
44
45			/**
46			* Makes and records specific method call for object prophecy.
47			*
48			* @param ObjectProphecy $prophecy
49			* @param string $methodName
50			* @param array $arguments
51			*
52			* @return mixed Returns null if no promise for prophecy found or promise return value.
53			*
54			* @throws \Prophecy\Exception\Call\UnexpectedCallException If no appropriate method prophecy found
55			*/
56			public function makeCall(ObjectProphecy $prophecy, $methodName, array $arguments)
57			{
58			// For efficiency exclude 'args' from the generated backtrace
59			if (PHP_VERSION_ID >= 50400) {
60			// Limit backtrace to last 3 calls as we don't use the rest
61			// Limit argument was introduced in PHP 5.4.0
62			$backtrace = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 3);
63			} elseif (defined('DEBUG_BACKTRACE_IGNORE_ARGS')) {
64			// DEBUG_BACKTRACE_IGNORE_ARGS was introduced in PHP 5.3.6
65			$backtrace = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS);
66			} else {
67			$backtrace = debug_backtrace();
68			}
69
70			$file = $line = null;
71			if (isset($backtrace[2]) && isset($backtrace[2]['file'])) {
72			$file = $backtrace[2]['file'];
73			$line = $backtrace[2]['line'];
74			}
75
76			// If no method prophecies defined, then it's a dummy, so we'll just return null
77			if ('__destruct' === $methodName \|\| 0 == count($prophecy->getMethodProphecies())) {
78			$this->recordedCalls[] = new Call($methodName, $arguments, null, null, $file, $line);
79
80			return null;
81			}
82
83			// There are method prophecies, so it's a fake/stub. Searching prophecy for this call
84			$matches = array();
85			foreach ($prophecy->getMethodProphecies($methodName) as $methodProphecy) {
86			if (0 < $score = $methodProphecy->getArgumentsWildcard()->scoreArguments($arguments)) {
87			$matches[] = array($score, $methodProphecy);
88			}
89			}
90
91			// If fake/stub doesn't have method prophecy for this call - throw exception
92			if (!count($matches)) {
93			throw $this->createUnexpectedCallException($prophecy, $methodName, $arguments);
94			}
95
96			// Sort matches by their score value
97			@usort($matches, function ($match1, $match2) { return $match2[0] - $match1[0]; });
			0 ignored issues – show Security Best Practice introduced 2015-11-20 22:14 UTC by Report Bug Copy Issue Report It seems like you do not handle an error condition here. This can introduce security issues, and is generally not recommended. If you suppress an error, we recommend checking for the error condition explicitly: // For example instead of @mkdir($dir); // Better use if (@mkdir($dir) === false) { throw new \RuntimeException('The directory '.$dir.' could not be created.'); } Loading history...
98
99			// If Highest rated method prophecy has a promise - execute it or return null instead
100			$methodProphecy = $matches[0][1];
101			$returnValue = null;
102			$exception = null;
103			if ($promise = $methodProphecy->getPromise()) {
104			try {
105			$returnValue = $promise->execute($arguments, $prophecy, $methodProphecy);
106			} catch (\Exception $e) {
107			$exception = $e;
108			}
109			}
110
111			if ($methodProphecy->hasReturnVoid() && $returnValue !== null) {
112			throw new MethodProphecyException(
113			"The method \"$methodName\" has a void return type, but the promise returned a value",
114			$methodProphecy
115			);
116			}
117
118			$this->recordedCalls[] = new Call(
119			$methodName, $arguments, $returnValue, $exception, $file, $line
120			);
121
122			if (null !== $exception) {
123			throw $exception;
124			}
125
126			return $returnValue;
127			}
128
129			/**
130			* Searches for calls by method name & arguments wildcard.
131			*
132			* @param string $methodName
133			* @param ArgumentsWildcard $wildcard
134			*
135			* @return Call[]
136			*/
137			public function findCalls($methodName, ArgumentsWildcard $wildcard)
138			{
139			return array_values(
140			array_filter($this->recordedCalls, function (Call $call) use ($methodName, $wildcard) {
141			return $methodName === $call->getMethodName()
142			&& 0 < $wildcard->scoreArguments($call->getArguments())
143			;
144			})
145			);
146			}
147
148			private function createUnexpectedCallException(ObjectProphecy $prophecy, $methodName,
149			array $arguments)
150			{
151			$classname = get_class($prophecy->reveal());
152			$indentationLength = 8; // looks good
153			$argstring = implode(
154			",\n",
155			$this->indentArguments(
156			array_map(array($this->util, 'stringify'), $arguments),
157			$indentationLength
158			)
159			);
160
161			$expected = implode(
162			"\n",
163			array_map(
164			function (MethodProphecy $methodProphecy) use ($indentationLength) {
165			return sprintf(
166			" - %s(\n".
167			"%s\n".
168			" )",
169			$methodProphecy->getMethodName(),
170			implode(
171			",\n",
172			$this->indentArguments(
173			array_map(
174			function ($token) {
175			return (string) $token;
176			},
177			$methodProphecy->getArgumentsWildcard()->getTokens()
178			),
179			$indentationLength
180			)
181			)
182			);
183			},
184			call_user_func_array('array_merge', $prophecy->getMethodProphecies())
185			)
186			);
187
188			return new UnexpectedCallException(
189			sprintf(
190			"Unexpected method call on %s:\n".
191			" - %s(\n".
192			"%s\n".
193			" )\n".
194			"expected calls were:\n".
195			"%s",
196
197			$classname, $methodName, $argstring, $expected
198			),
199			$prophecy, $methodName, $arguments
200
201			);
202			}
203
204			private function indentArguments(array $arguments, $indentationLength)
205			{
206			return preg_replace_callback(
207			'/^/m',
208			function () use ($indentationLength) {
209			return str_repeat(' ', $indentationLength);
210			},
211			$arguments
212			);
213			}
214			}
215

phpspec / prophecy

Pull Request — master (#408)

CallCenter::createUnexpectedCallException() B

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like