implemented mocking of functions

Author: DavertMik

CHANGELOG.md

@@ -2,6 +2,9 @@
 
 #### 0.5.0
 
+* Mocking functions implemented with test::func method *2014-10-10*
+* Fixed mocking functions with arguments passed by reference #34 by @tampe125 *2014-10-09*
+* Fixed mocking functions with arguments passed by reference #34 by @tampe125 *2014-10-08*
 * Fixed passing arguments by reference in InstanceProxy. Thanks to @tampe125. Issue #39 *2014-10-08*
 * Debug mode can be disabled in options with debug => false *2014-10-08*
 * Updated to Go\Aop 0.5.0

RoboFile.php

@@ -6,7 +6,8 @@ class Robofile extends \Robo\Tasks
     protected $docs = [
         'docs/Test.md' => 'AspectMock\Test',
         'docs/ClassProxy.md' => 'AspectMock\Proxy\ClassProxy',
-        'docs/InstanceProxy.md' => 'AspectMock\Proxy\InstanceProxy'
+        'docs/InstanceProxy.md' => 'AspectMock\Proxy\InstanceProxy',
+        'docs/FuncProxy.md' => 'AspectMock\Proxy\FuncProxy'
     ];
 
     protected function version()
@@ -52,6 +53,7 @@ function (\ReflectionMethod $m, $doc) {
                         $doc = str_replace(array(' @', "\n@"), array("  * ", "\n * "), $doc);
                         return $doc;
                     })
+                ->processProperty(false)
                 ->run();
         }
     }

docs/ClassProxy.md

@@ -40,9 +40,7 @@ $user->getCallsForMethod('someMethod') // [ ['arg1', 'arg2'] ]
 ?>
 ```
 
-#### *public* classNameName of a class.
 
-@var
 
 
 

docs/FuncProxy.md

@@ -0,0 +1,48 @@
+
+## AspectMock\Proxy\FuncProxy
+
+* *Extends* `AspectMock\Proxy\Verifier`
+
+FuncProxy is a wrapper around mocked function, used to verify function calls.
+Has the same verification methods as `InstanceProxy` and `ClassProxy` do.
+
+Usage:
+
+```php
+<?php
+namespace Acme\User;
+$func = test::func('Acme\User', 'strlen', 10);
+strlen('hello');
+strlen('world');
+$func->verifyInvoked(); // true
+$func->verifyInvoked(['hello']); // true
+$func->verifyInvokedMultipleTimes(2);
+$func->verifyNeverInvoked(['bye']);
+
+```
+
+
+
+
+
+
+
+
+
+
+#### *public* verifyInvoked($params = null) 
+ * `param null` $params
+
+#### *public* verifyInvokedOnce($params = null) 
+ * `param null` $params
+
+#### *public* verifyNeverInvoked($params = null) 
+ * `param null` $params
+
+#### *public* verifyInvokedMultipleTimes($times, $params = null) 
+ * `param` $times
+ * `param null` $params
+
+
+#### *public* getCallsForMethod($func) 
+

docs/InstanceProxy.md

@@ -53,9 +53,7 @@ $user->getCallsForMethod('someMethod') // [ ['arg1', 'arg2'] ]
 ```
 
 
-#### *public* classNameName of a class.
 
-@var
 
 
 

docs/Test.md

@@ -31,6 +31,7 @@ Example:
 $user = test::double(new User, ['getName' => 'davert']);
 $user->getName() // => davert
 $user->verifyInvoked('getName'); // => success
+$user->getObject() // => returns instance of User, i.e. real, not proxified object
 
 # with closure
 $user = test::double(new User, ['getName' => function() { return $this->login; }]);
@@ -132,10 +133,7 @@ If class is already defined, `test::spec` will act as `test::double`.
  * return Verifier
 
 
-#### *public static* methods($classOrObject, array $only = Array
-(
-)
-) 
+#### *public static* methods($classOrObject, array $only = Array ( ) ) 
 Replaces all methods in a class with a dummies, except specified.
 
 ``` php
@@ -179,6 +177,42 @@ When declared in `test::double` not exists, AspectMock will try to match it by p
 To ignore namespace guessing, use `\` in the beginning of class name: `\User`;
 
 
+#### *public static* func($namespace, $function, $body) 
+Replaces function in provided namespace with user-defined function or value that function returns;
+Function is restored to original on cleanup.
+
+```php
+<?php
+namespace demo;
+test::func('demo', 'date', 2004);
+date('Y'); // 2004
+
+test::func('demo', 'date', function($format) {
+   if ($format == 'Y') {
+     return 2004;
+   } else {
+     return \date($param);
+   }
+}
+
+```
+
+Mocked functions can be verified for calls.
+
+```php
+<?php
+namespace demo;
+$func = test::func('demo', 'date', 2004);
+date('Y'); // 2004
+$func->verifyInvoked();
+$func->verifyInvokedOnce(['Y']);
+```
+
+ * `param` $namespace
+ * `param` $function
+ * `param` $body
+ * return Proxy\FuncProxy
+
 #### *public static* clean($classOrInstance = null) 
 Clears test doubles registry.
 Should be called between tests.

src/AspectMock/Core/Mocker.php

@@ -1,5 +1,6 @@
 <?php
 namespace AspectMock\Core;
+use AspectMock\Intercept\FunctionInjector;
 use Go\Aop\Aspect;
 use AspectMock\Intercept\MethodInvocation;
 
@@ -35,6 +36,23 @@ public function fakeMethodsAndRegisterCalls($class, $declaredClass, $method, $pa
         return $result;
     }
 
+    public function fakeFunctionAndRegisterCalls($namespace, $function, $args)
+    {
+        $result = __AM_CONTINUE__;
+        $fullFuncName = "$namespace\\$function";
+        Registry::registerFunctionCall($fullFuncName, $args);
+
+        if (isset($this->funcMap[$fullFuncName])) {
+            $func = $this->funcMap[$fullFuncName];
+            if (is_callable($func)) {
+                $result = call_user_func_array($func, $args);
+            } else {
+                $result = $func;
+            }
+        }
+        return $result;
+    }
+
     protected function invokeFakedMethods(MethodInvocation $invocation)
     {
         $method = $invocation->getMethod();
@@ -172,6 +190,16 @@ public function registerObject($object, $params = array())
         $this->methodMap = array_merge($this->methodMap, array_keys($params));
     }
 
+    public function registerFunc($namespace, $func, $body)
+    {
+        if (!function_exists("$namespace\\$func")) {
+            $injector = new FunctionInjector($namespace, $func);
+            $injector->save();
+            $injector->inject();
+        }
+        $this->funcMap["$namespace\\$func"] = $body;
+    }
+
     public function clean($objectOrClass = null)
     {
         if (!$objectOrClass) {

src/AspectMock/Core/Registry.php

@@ -13,6 +13,7 @@ class Registry {
 
     protected static $classCalls = [];
     protected static $instanceCalls = [];
+    protected static $funcCalls = [];
     protected static $ns = '';
 
     /**
@@ -30,9 +31,9 @@ static function registerObject($object, $params = array())
         self::$mocker->registerObject($object, $params);
     }
 
-    static function registerFunc($func, $resultOrClosure)
+    static function registerFunc($namespace, $function, $resultOrClosure)
     {
-        self::$mocker->registerFunc($func, $resultOrClosure);
+        self::$mocker->registerFunc($namespace, $function, $resultOrClosure);
     }
 
     static function getClassCallsFor($class)
@@ -50,6 +51,11 @@ static function getInstanceCallsFor($instance)
             : [];
     }
 
+    static function getFuncCallsFor($func)
+    {
+        return isset(self::$funcCalls[$func]) ? self::$funcCalls[$func] : [];
+    }
+
     static function clean($classOrInstance = null)
     {
         $classOrInstance = self::getRealClassOrObject($classOrInstance);
@@ -71,6 +77,7 @@ static function cleanInvocations()
     {
         self::$instanceCalls = [];
         self::$classCalls = [];
+        self::$funcCalls = [];
     }
 
     static function registerInstanceCall($instance, $method, $args = array())
@@ -94,6 +101,15 @@ static function registerClassCall($class, $method, $args = array())
 
     }
 
+    static function registerFunctionCall($functionName, $args)
+    {
+        if (!isset(self::$funcCalls[$functionName])) self::$funcCalls[$functionName] = [];
+
+        isset(self::$funcCalls[$functionName])
+            ? self::$funcCalls[$functionName][] = $args
+            : self::$funcCalls[$functionName] = array($args);
+    }
+
     public static function getRealClassOrObject($classOrObject)
     {
         if ($classOrObject instanceof ClassProxy) return $classOrObject->className;

src/AspectMock/Intercept/BeforeMockTransformer.php

@@ -10,8 +10,8 @@
 use TokenReflection\ReflectionClass as ParsedClass;
 use TokenReflection\ReflectionFileNamespace as ParsedFileNamespace;
 
-class BeforeMockTransformer extends WeavingTransformer {
-
+class BeforeMockTransformer extends WeavingTransformer
+{
     protected $before = " if ((\$__am_res = __amock_before(\$this, __CLASS__, __FUNCTION__, array(%s), false)) !== __AM_CONTINUE__) return \$__am_res; ";
     protected $beforeStatic = " if ((\$__am_res = __amock_before(get_called_class(), __CLASS__, __FUNCTION__, array(%s), true)) !== __AM_CONTINUE__) return \$__am_res; ";
 
@@ -66,33 +66,42 @@ public function transform(StreamMetaData $metadata)
 
                 $methods = $class->getMethods();
                 foreach ($methods as $method) {
-                    /** @var $method ReflectionMethod`  **/
-                    if ($method->getDeclaringClassName() != $class->getName()) continue;
+                    /** @var $method ReflectionMethod`  * */
+                    if ($method->getDeclaringClassName() != $class->getName()) {
+                        continue;
+                    }
                     // methods from traits have the same declaring class name, so check that the filenames match, too
-                    if ($method->getFileName() != $class->getFileName()) continue;
-                    if ($method->isAbstract()) continue;
-                     $beforeDefinition = $method->isStatic()
+                    if ($method->getFileName() != $class->getFileName()) {
+                        continue;
+                    }
+                    if ($method->isAbstract()) {
+                        continue;
+                    }
+                    $beforeDefinition = $method->isStatic()
                         ? $this->beforeStatic
                         : $this->before;
                     $reflectedParams = $method->getParameters();
 
                     $params = [];
 
                     foreach ($reflectedParams as $reflectedParam) {
-                        /** @var $reflectedParam ReflectionParameter  **/
-                        $params[] = ($reflectedParam->isPassedByReference() ? '&$' : '$').$reflectedParam->getName();
+                        /** @var $reflectedParam ReflectionParameter  * */
+                        $params[] = ($reflectedParam->isPassedByReference() ? '&$' : '$') . $reflectedParam->getName();
                     }
                     $params = implode(", ", $params);
                     $beforeDefinition = sprintf($beforeDefinition, $params);
-                    for ($i = $method->getStartLine()-1; $i < $method->getEndLine()-1; $i++) {
-                        $pos = strpos($dataArray[$i],'{');
-                        if ($pos === false) continue;
-                        $dataArray[$i] = substr($dataArray[$i], 0, $pos+1).$beforeDefinition.substr($dataArray[$i], $pos+1);
+                    for ($i = $method->getStartLine() - 1; $i < $method->getEndLine() - 1; $i++) {
+                        $pos = strpos($dataArray[$i], '{');
+                        if ($pos === false) {
+                            continue;
+                        }
+                        $dataArray[$i] = substr($dataArray[$i], 0, $pos + 1) . $beforeDefinition . substr($dataArray[$i], $pos + 1);
                         break;
                     }
                 }
             }
         }
         $metadata->source = implode("\n", $dataArray);
     }
+
 }

src/AspectMock/Intercept/FunctionInjector.php

@@ -0,0 +1,56 @@
+<?php
+namespace AspectMock\Intercept;
+
+class FunctionInjector
+{
+    protected $template = <<<EOF
+<?php
+namespace {{ns}};
+if (!function_exists('{{ns}}\{{func}}')) {
+function {{func}}() {
+    if ((\$__am_res = __amock_before_func('{{ns}}','{{func}}', func_get_args())) !== __AM_CONTINUE__) {
+        return \$__am_res;
+    }
+    return call_user_func_array('{{func}}', func_get_args());
+}
+}
+EOF;
+    protected $namespace;
+    protected $function;
+    protected $fileName;
+
+    function __construct($namespace, $function)
+    {
+        $this->namespace = $namespace;
+        $this->function = $function;
+        $this->place('ns', $this->namespace);
+        $this->place('func', $this->function);
+
+    }
+
+    public function save()
+    {
+        $this->fileName = tempnam(sys_get_temp_dir(), $this->function);
+        file_put_contents($this->fileName, $this->template);
+    }
+
+    public function inject()
+    {
+        require_once $this->fileName;
+    }
+
+    public function getFileName()
+    {
+        return $this->fileName;
+    }
+
+    public function getPHP()
+    {
+        return $this->template;
+    }
+
+    protected function place($var, $value)
+    {
+        $this->template = str_replace("{{{$var}}}", $value, $this->template);
+    }
+}