I wanted to put a unit test around some PHP code that use a socket, and of course hit a problem: how do I control what a call to fgets returns? You see, in PHP, you cannot replace one of the built-in functions: you get told "Fatal error: Cannot redeclare fgets() ...".
Rename Then Override Then Rename Again!
I
asked on StackOverflow, not expecting much response, but almost immediately got told about the
rename_function(). Wow! I'd never heard of that before. The challenge then was that this is in the apd extension, which was last released in 2004 and does not support php 5.3. I've put instructions on how to get it installed on the StackOverflow question so I won't repeat them here.
The next challenge you'll meet is that naively using rename_function to a move a function out of the way fails. You still get told "Fatal error: Cannot redeclare fgets() ..." ?! You need to use override_function to replace its behaviour. All Done? Not quite, what you discover next is that you can only override one function. Eh?! But all is not lost: the comments in the marvellous PHP manual described the solution, which goes like:
- Use override_function to define the new behaviour
- Use rename_function to give a better name to the old, original function.
However, when you go to restore a function (see further down), it turns out that does not work. What you actually need to do is:
- Use rename_function to give a name to the old, original function, so we can find it later.
- Use override_function to define the new behaviour
- Use rename_function to give a dummy name to __overridden__
You do those three steps for each function you want
to replace. Here is a complete example that shows how to override fgets
and feof to return strings from a global array. NOTE: this is a
simplistic example; I should really be overriding fopen and fclose too
(they'd be set to do nothing).
$GLOBALS['fgets_strings']=array(
"Line 1",
"Line 2",
"Line 3",
);
rename_function('fgets','real_fgets');
override_function('fgets','$handle,$length=null','return array_shift($GLOBALS["fgets_strings"])."\n";');
rename_function("__overridden__", 'dummy_fgets');
rename_function('feof','real_feof');
override_function('feof','$handle','return count($GLOBALS["fgets_strings"])==0;');
rename_function("__overridden__", 'dummy_feof');
$fname="rename_test.php";
$fp=fopen($fname,"r");
if($fp)while(!feof($fp)){
echo fgets($fp);
}
fclose($fp);
Mock The Sock(et)
So, what about the original challenge, to unit test a socket function? Here is some very minimal code to request a page from a web server; let's pretend we want to test this code:
$fp=fsockopen('127.0.0.1',80);
fwrite($fp,"GET / HTTP/1.1\r\n");
fwrite($fp,"Host: 127.0.0.1\r\n");
fwrite($fp,"\r\n");
if($fp)while(!feof($fp)){
echo fgets($fp);
}
fclose($fp);
To take control of its behaviour, we prepend the following block; the above code does not have to be touched at all.
rename_function('fwrite','real_fwrite');
override_function('fwrite','$fp,$s','');
rename_function("__overridden__", 'dummy_fwrite');
rename_function('fsockopen','real_fsockopen');
override_function('fsockopen',
'$hostname,$port=-1,&$errno=null,&$errstr=null,$timeout=null',
'return fopen("socket_mock_contents.txt","r");'
);
rename_function("__overridden__", 'dummy_fsockopen');
I.e. We replace the call to fsockopen with a call to fopen, and tell it to read our special file. (If you don't want to use an external file, and instead want a fully self-contained test, with the contents in a string, you could use
phpstringstream or if you don't want Yet Another Dependency, you could write your own, as
the code is fairly short and straightforward )
The other thing to note about the above code is that we had to replace
fwrite as well. This is needed because we're creating a read-only stream to be the stand-in for a read-write stream. If you are using other functions (e.g.
ftell or
stream_set_blocking) you will need to consider if those functions need a mock version too.
The Fly In The Ointment
The thing about replacing a global function is that you're replacing a
global function, as in,
globally! Any other code that calls that function is going to call your mock version. Maybe we can get away with this with
fsockopen, but it becomes quite a major problem if you are replacing things like
fgets or
fwrite, in a phpUnit unit test, as phpUnit is quite likely to call those functions itself!
So, we want to restore the functions once we're done with them? It is very easy to get this wrong and get a segfault. You must use rename_function before using override_function, the first time. The following code has been tested and restores the behaviour of the above example:
override_function('fwrite','$fp,$s','return real_fwrite($fp,$s);');
rename_function("__overridden__", 'dummy2_fwrite');
override_function('fsockopen','$hostname,$port','return real_fsockopen($hostname,$port);');
rename_function("__overridden__", 'dummy2_fsockopen');
Notice how we still need to deal with
__overridden__ each time.
Food For Thought
There is another approach, which might be more robust. It involves checking inside each overridden function if this is the stream you want to be falsifying data for, and whenever it isn't you call the original versions. Here I'll show how to just do that with the fwrite function:
$GLOBALS["mock_fp"]=null;
rename_function('fwrite','real_fwrite');
override_function('fwrite','$fp,$s','
if($fp==$GLOBALS["mock_fp"]){echo "Skipping a fwrite.\n";return;} //Do nothing
return real_fwrite($fp,$s);
');
rename_function("__overridden__", 'dummy_fwrite');
rename_function('fsockopen','real_fsockopen');
override_function('fsockopen','$hostname,$port=-1,&$errno=null,&$errstr=null,$timeout=null',
'return $GLOBALS["mock_fp"]=fopen("socket_mock_contents.txt","r");');
rename_function("__overridden__", 'dummy_fsockopen');
Then we can test it, as follows:
$fp=fsockopen('127.0.0.1',80);
fwrite($fp,"GET / HTTP/1.1\r\n");
fwrite($fp,"Host: 127.0.0.1\r\n");
fwrite($fp,"\r\n");
if($fp)while(!feof($fp)){
echo fgets($fp);
}
fclose($fp);
$fp=fopen("tmp.txt","w");
fwrite($fp,"My output\n");
fclose($fp);
