Provided by: liboverload-filecheck-perl_0.013-2build3_amd64 
NAME
Overload::FileCheck - override/mock perl file check -X: -e, -f, -d, ...
VERSION
version 0.013
SYNOPSIS
Overload::FileCheck provides a way to mock one or more file checks. It is also possible
to mock stat/lstat functions using "mock_all_from_stat" and let Overload::FileCheck mock
for you for any other -X checks.
By using mock_all_file_checks you can set a hook function to reply any -X check.
#!perl
use strict;
use warnings;
use strict;
use warnings;
use Test::More;
use Overload::FileCheck q{:all};
my @exist = qw{cherry banana apple};
my @not_there = qw{not-there missing-file};
mock_all_file_checks( \&my_custom_check );
sub my_custom_check {
my ( $check, $f ) = @_;
if ( $check eq 'e' || $check eq 'f' ) {
return CHECK_IS_TRUE if grep { $_ eq $f } @exist;
return CHECK_IS_FALSE if grep { $_ eq $f } @not_there;
}
return CHECK_IS_FALSE if $check eq 'd' && grep { $_ eq $f } @exist;
# fallback to the original Perl OP
return FALLBACK_TO_REAL_OP;
}
foreach my $f (@exist) {
ok( -e $f, "-e $f is true" );
ok( -f $f, "-f $f is true" );
ok( !-d $f, "-d $f is false" );
}
foreach my $f (@not_there) {
ok( !-e $f, "-e $f is false" );
ok( !-f $f, "-f $f is false" );
}
unmock_all_file_checks();
done_testing;
DESCRIPTION
Overload::FileCheck provides a hook system to mock Perl filechecks OPs
With this module you can provide your own pure perl code when performing file checks using
one of the -X ops: -e, -f, -z, ...
<https://perldoc.perl.org/functions/-X.html>
-r File is readable by effective uid/gid.
-w File is writable by effective uid/gid.
-x File is executable by effective uid/gid.
-o File is owned by effective uid.
-R File is readable by real uid/gid.
-W File is writable by real uid/gid.
-X File is executable by real uid/gid.
-O File is owned by real uid.
-e File exists.
-z File has zero size (is empty).
-s File has nonzero size (returns size in bytes).
-f File is a plain file.
-d File is a directory.
-l File is a symbolic link (false if symlinks aren't
supported by the file system).
-p File is a named pipe (FIFO), or Filehandle is a pipe.
-S File is a socket.
-b File is a block special file.
-c File is a character special file.
-t Filehandle is opened to a tty.
-u File has setuid bit set.
-g File has setgid bit set.
-k File has sticky bit set.
-T File is an ASCII or UTF-8 text file (heuristic guess).
-B File is a "binary" file (opposite of -T).
-M Script start time minus file modification time, in days.
-A Same for access time.
-C Same for inode change time (Unix, may differ for other
platforms)
Also view pp_sys.c from the Perl source code, where are defined the original OPs.
In addition it's also possible to mock the Perl OP "stat" and "lstat", read "Mocking stat
and lstat" section for more details.
Usage and Examples
When using this module, you can decide to mock filecheck OPs on import or later at run
time.
Mocking filecheck at import time
You can mock multiple filecheck at import time. Note that the ':check' will import
constants like: CHECK_IS_TRUE, CHECK_IS_FALSE, FALLBACK_TO_REAL_OP which are recommended
return values to use in your hook functions.
#!perl
use strict;
use warnings;
use Overload::FileCheck '-e' => \&my_dash_e, -f => sub { 1 }, ':check';
# example of your own callback function to mock -e
# when returning
# 0: the test is false
# 1: the test is true
# -1: you want to use the answer from Perl itself :-)
sub dash_e {
my ($file_or_handle) = @_;
# return true on -e for this specific file
return CHECK_IS_TRUE if $file_or_handle eq '/this/file/is/not/there/but/act/like/if/it/was';
# claim that /tmp is not available even if it exists
return CHECK_IS_FALSE if $file_or_handle eq '/tmp';
# delegate the answer to the Perl CORE -e OP
# as we do not want to control these files
return FALLBACK_TO_REAL_OP;
}
Mocking filecheck at run time
You can also get a similar behavior by declaring the overload later at run time.
#!perl
use strict;
use warnings;
use Overload::FileCheck q(:all);
mock_file_check( '-e' => \&my_dash_e );
mock_file_check( '-f' => sub { CHECK_IS_TRUE } );
sub dash_e {
my ($file_or_fh) = @_;
# return true on -e for this specific file
return CHECK_IS_TRUE if $file_or_fh eq '/this/file/is/not/there/but/act/like/if/it/was';
# claim that /tmp is not available even if it exists
return CHECK_IS_FALSE if $file_or_fh eq '/tmp';
# delegate the answer to the Perl CORE -e OP
# as we do not want to control these files
return FALLBACK_TO_REAL_OP;
}
Check helpers to use in your callback function
In your callback function you should use the following helpers to return.
CHECK_IS_FALSE: use this constant when the test is false
CHECK_IS_TRUE: use this when you the test is true
FALLBACK_TO_REAL_OP: you want to delegate the answer to Perl itself :-)
It's also possible to return one integer. Checks like "-s", "-M", "-C", "-A" can return
any integers.
Example:
use Overload::FileCheck q(:all);
mock_file_check( '-s' => \&my_dash_s );
sub my_dash_s {
my ( $file_or_handle ) = @_;
if ( $file_or_handle eq '/a/b/c' ) {
return 42;
}
return FALLBACK_TO_REAL_OP;
}
Tracing all file checks usage
You can trace all file checks in your codebase without altering it.
#!perl
use strict;
use warnings;
use Carp;
use Overload::FileCheck q{:all};
mock_all_file_checks( \&my_custom_check );
sub my_custom_check {
my ( $check, $f ) = @_;
local $Carp::CarpLevel = 2; # do not display Overload::FileCheck stack
printf( "# %-10s called from %s", "-$check '$f'", Carp::longmess() );
# fallback to the original Perl OP
return FALLBACK_TO_REAL_OP;
}
-d '/root';
-l '/root';
-e '/';
-d '/';
unmock_all_file_checks();
__END__
# The output looks similar to
-d '/root' called from at t/perldoc_mock-all-file-check-trace.t line 26.
-l '/root' called from at t/perldoc_mock-all-file-check-trace.t line 27.
-e '/' called from at t/perldoc_mock-all-file-check-trace.t line 28.
-d '/' called from at t/perldoc_mock-all-file-check-trace.t line 29.
Mock one or more file checks: -e, -f
You can mock a single file check type like '-e', '-f', ...
#!perl
use strict;
use warnings;
use Overload::FileCheck qw{mock_file_check unmock_file_check unmock_all_file_checks :check};
use Errno ();
# all -f checks will be true from now
mock_file_check( '-f' => sub { 1 } );
# mock all calls to -e and delegate to the function dash_e
mock_file_check( '-e' => \&dash_e );
# example of your own callback function to mock -e
# when returning
# 0: the test is false
# 1: the test is true
# -1: you want to use the answer from Perl itself :-)
sub dash_e {
my ($file_or_fh) = @_;
# return true on -e for this specific file
return CHECK_IS_TRUE
if $file_or_fh eq '/this/file/is/not/there/but/act/like/if/it/was';
# claim that /tmp is not available even if it exists
if ( $file_or_fh eq '/tmp' ) {
# you can set Errno to any custom value
# or it would be set to Errno::ENOENT() by default
$! = Errno::ENOENT(); # set errno to "No such file or directory"
return CHECK_IS_FALSE;
}
# delegate the answer to the Perl CORE -e OP
# as we do not want to control these files
return FALLBACK_TO_REAL_OP;
}
# unmock -e and -f
unmock_file_check('-e');
unmock_file_check('-f');
unmock_file_check(qw{-e -f});
# or unmock all existing filecheck
unmock_all_file_checks();
Mock check calls at import time
You can also mock the check functions at import time by providing a check test and a
custom function
#!perl
use strict;
use warnings;
use Test::More;
use Overload::FileCheck '-e' => \&my_dash_e, q{:check};
# Mock one or more check
#use Overload::FileCheck '-e' => \&my_dash_e, '-f' => sub { 1 }, 'x' => sub { 0 }, ':check';
my @exist = qw{cherry banana apple};
my @not_there = qw{chocolate and peanuts};
sub my_dash_e {
my $f = shift;
note "mocked -e called for", $f;
return CHECK_IS_TRUE if grep { $_ eq $f } @exist;
return CHECK_IS_FALSE if grep { $_ eq $f } @not_there;
# we have no idea about these files
return FALLBACK_TO_REAL_OP;
}
foreach my $f (@exist) {
ok( -e $f, "file '$f' exists" );
}
foreach my $f (@not_there) {
ok( !-e $f, "file '$f' exists" );
}
# this is using the fallback logic '-1'
ok -e $0, q[$0 is there];
ok -e $^X, q[$^X is there];
done_testing;
Mocking stat and lstat
How to mock stat?
Here is a short sample how you can mock stat and lstat. This is an extract from the
testsuite, Test2::* modules are just there to illustrate the behavior. You should not
necessary use them in your code.
For more advanced samples, browse to the source code and check the test files in t or
examples directories.
#!perl
use strict;
use warnings;
use Test2::Bundle::Extended;
use Test2::Tools::Explain;
use Test2::Plugin::NoWarnings;
use Overload::FileCheck q(:all);
# our helper would be called for every stat & lstat calls
mock_stat( \&my_stat );
sub my_stat {
my ( $opname, $file_or_handle ) = @_;
# $opname can be 'stat' or 'lstat'
# in this sample only mock stat, leave lstat alone
return FALLBACK_TO_REAL_OP() if $opname eq 'lstat';
my $f = $file_or_handle; # alias for readability
# return an array ref with 13 elements containing the stat output
return [ 1 .. 13 ] if $f eq $0;
my $fake_stat = [ (0) x 13 ];
# you also have access to some constants
# to set the stat values in the correct slot
# this is using some fake values, without any specific meaning...
$fake_stat->[ST_DEV] = 1;
$fake_stat->[ST_INO] = 2;
$fake_stat->[ST_MODE] = 4;
$fake_stat->[ST_NLINK] = 8;
$fake_stat->[ST_UID] = 16;
$fake_stat->[ST_GID] = 32;
$fake_stat->[ST_RDEV] = 64;
$fake_stat->[ST_SIZE] = 128;
$fake_stat->[ST_ATIME] = 256;
$fake_stat->[ST_MTIME] = 512;
$fake_stat->[ST_CTIME] = 1024;
$fake_stat->[ST_BLKSIZE] = 2048;
$fake_stat->[ST_BLOCKS] = 4096;
return $fake_stat if $f eq 'fake.stat';
# can also return stats as a hash ref
return { st_dev => 1, st_atime => 987654321 } if $f eq 'hash.stat';
return {
st_dev => 1,
st_ino => 2,
st_mode => 3,
st_nlink => 4,
st_uid => 5,
st_gid => 6,
st_rdev => 7,
st_size => 8,
st_atime => 9,
st_mtime => 10,
st_ctime => 11,
st_blksize => 12,
st_blocks => 13,
} if $f eq 'hash.stat.full';
# return an empty array if you want to mark the file as not available
return [] if $f eq 'file.is.not.there';
# fallback to the regular OP
return FALLBACK_TO_REAL_OP();
}
is [ stat($0) ], [ 1 .. 13 ], 'stat is mocked for $0';
is [ stat(_) ], [ 1 .. 13 ],
'_ also works: your mocked function is not called';
is [ stat('fake.stat') ],
[ 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096 ], 'fake.stat';
is [ stat('hash.stat.full') ], [ 1 .. 13 ], 'hash.stat.full';
unmock_stat();
done_testing;
Convenient constants available when mocking stat
When mocking stat or lstat function your callback function should return one of the
following
either one ARRAY Ref containing 13 entries as described by the stat function (in the same
order)
or an empty ARRAY Ref, if the file does not exist
or one HASH ref using one or more of the following keys: st_dev, st_ino, st_mode,
st_nlink, st_uid, st_gid, st_rdev, st_size, st_atime, st_mtime, st_ctime, st_blksiz,
st_blocks
or return FALLBACK_TO_REAL_OP when you want to let Perl take back the control for that
file
In order to manipulate the ARRAY ref and insert/update one specific entry, some constant
are available to access to the correct index via a 'name':
ST_DEV
ST_INO
ST_MODE
ST_NLINK
ST_UID
ST_GID
ST_RDEV
ST_SIZE
ST_ATIME
ST_MTIME
ST_CTIME
ST_BLKSIZE
ST_BLOCKS
Mocking all file checks from a single 'stat' function
A recommended option is to only mock the 'stat' and 'lstat' function and let
Overload::FileCheck mock for you all file checks: -e, -f, -s, -z, ...
By doing so, using '_' or '*_' (a.k.a. PL_defgv) in your filecheck would work without any
extra effort.
-d "/my/file" && -s _
Netherway some limitations exist. Indeed the checks '-B' and '-T' are using some
heuristics to determine if the file is a binary or a text. This would require more than
just a simple stat output. In these cases you can mock the -B and -T to your own
functions.
mock_file_check( '-B' => sub { ... } );
mock_file_check( '-T' => sub { ... } );
mock_all_from_stat
By using 'mock_all_from_stat' function, you will only provide a 'fake' stat / lstat
function and let Overload::FileCheck provide the hooks for all common checks
#!perl
use strict;
use warnings;
# setup at import time
use Overload::FileCheck '-from-stat' => \&mock_stat_from_sys, qw{:check :stat};
# or set it later at run time
# mock_all_from_stat( \&my_stat );
sub mock_stat_from_sys {
my ( $stat_or_lstat, $f ) = @_;
# $stat_or_lstat would be set to 'stat' or 'lstat' depending
# if it's a 'stat' or 'lstat' call
if ( defined $f && $f eq 'mocked.file' ) { # "<<$f is mocked>>"
return [ # return a fake stat output (regular file)
64769, 69887159, 33188, 1, 0, 0, 0, 13,
1539928982, 1539716940, 1539716940,
4096, 8
];
return stat_as_file();
return []; # if the file is missing
}
# let Perl answer the stat question for us
return FALLBACK_TO_REAL_OP;
}
# ...
# later in your code
if ( -e 'mocked.file' && -f _ && !-d _ ) {
print "# This file looks real...\n";
}
# ...
# you can unmock the OPs at anytime
Overload::FileCheck::unmock_all_file_checks();
Using stat_as_* helpers
When mocking the stat functions you might consider using one of the 'stat_as_*' helper.
Available functions are:
stat_as_directory
stat_as_file
stat_as_symlink
stat_as_socket
stat_as_chr
stat_as_block
All of these functions take some optional arguments to set: uid, gid, size, atime, mtime,
ctime, perms, size. Example:
use Overload::FileCheck -from-stat => \&my_stat, q{:check};
sub my_stat {
my ( $stat_or_lstat, $f_or_fh ) = @_;
return stat_as_file() if $f_or_fh eq 'fake.file';
return stat_as_directory( uid => 0, gid => 'root' ) if $f_or_fh eq 'fake.dir';
return stat_as_file( mtime => time() ) if $f_or_fh eq 'touch.file';
return stat_as_file( perms => 0755 ) if $f_or_fh eq 'touch.file.0755';
return FALLBACK_TO_REAL_OP;
}
Available functions
mock_file_check( $check, CODE )
mock_file_check function is used to mock one of the filecheck op.
The first argument is one of the file check: '-f', '-e', ... where the dash is optional.
It also accepts 'e', 'f', ...
When trying to mock a filecheck already mocked, the function will die with an error like
-f is already mocked by Overload::FileCheck
This would guarantee that you are not mocking multiple times the same filecheck in your
codebase.
Otherwise returns 1 on success.
# this is probably a very bad idea to do this in your codebase
# but can be useful for some testing
# in that sample all '-e' checks will always return true...
mock_file_check( '-e' => sub { 1 } )
unmock_file_check( $check, [@extra_checks] )
Disable the effect of one or more specific mock. The argument to unmock_file_check can be
a list or a single scalar value. The leading dash is optional.
unmock_file_check( '-e' );
unmock_file_check( 'e' ); # also work without the dash
unmock_file_check( qw{-e -f -z} );
unmock_file_check( qw{e f} ); # also work without the dashes
unmock_all_file_checks()
By a simple call to unmock_all_file_checks, you would disable the effect of overriding the
filecheck OPs. (not that the XS code is still plugged in, but fallback as soon as possible
to the original OP)
mock_stat( CODE )
mock_stat provides one interface to setup a hook for all "stat" and "lstat" calls. It's
slighly different than the other mock functions. As the first argument passed to the hook
function would be a string 'stat' or 'lstat'.
You can get a more advanced hook sample from "Mocking stat".
use Overload::FileCheck q(:all);
# our helper would be called for every stat & lstat calls
mock_stat( \&my_stat );
sub my_stat {
my ( $opname, $file_or_handle ) = @_;
...
return FALLBACK_TO_REAL_OP;
}
unmock_stat()
By calling unmock_stat, you would disable any previous hook set using mock_stat
mock_all_from_stat( CODE )
By providing a single hook for 'stat' and 'lstat' you let OverLoad::FileCheck take care of
mocking all other -X checks.
read " Mocking all file checks from a single 'stat' function" for sample usage.
stat_as_directory( %OPTS )
Create a stat array ref for a directory. %OPTS is optional and can set one or more using
arguments among: uid, gid, size, atime, mtime, ctime, perms, size. read the section
"Using stat_as_* helpers" for some sample usages.
stat_as_file( %OPTS )
Create a stat array ref for a regular file view stat_as_directory and "Using stat_as_*
helpers" for some sample usages
stat_as_symlink( %OPTS )
Create a stat array ref for a symlink view stat_as_directory and "Using stat_as_* helpers"
for some sample usages
stat_as_socket( %OPTS )
Create a stat array ref for a socket view stat_as_directory and "Using stat_as_* helpers"
for some sample usages
stat_as_chr( %OPTS )
Create a stat array ref for an empty character device view stat_as_directory and "Using
stat_as_* helpers" for some sample usages
stat_as_block( %OPTS )
Create a stat array ref for an empty block device view stat_as_directory and "Using
stat_as_* helpers" for some sample usages
Notice
This is a very early development stage and some behavior might change before the release
of a more stable build.
Known Limitations
This is design for Unit Test purpose
This code was mainly designed to be used during unit tests. It's far from being optimized
at this time.
Mock as soon as possible
Code loaded/interpreted before mocking a file check, would not take benefit of
Overload::FileCheck. You probably want to load and call the mock function of
Overload::FileCheck as early as possible.
Empty string instead of Undef
Several test operators once mocked will not return the expected 'undef' value but one
empty string instead. This is a future improvement. If you check the output of -X
operators in boolean context it should not impact you.
-B and -T are using heuristics
File check operators like -B and -T are using heuristics to guess if the file content is
binary or text. By using mock_all_from_stat or ('-from-stat' at import time), we cannot
provide an accurate -B or -T checks. You would need to provide a custom hooks for them
TODO
support for 'undef' using CHECK_IS_UNDEF as valid return (in addition to CHECK_IS_FALSE)
LICENSE
This software is copyright (c) 2018 by cPanel, Inc.
This is free software; you can redistribute it and/or modify it under the same terms as
the Perl 5 programming language system itself.
DISCLAIMER OF WARRANTY
BECAUSE THIS SOFTWARE IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE SOFTWARE,
TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE
COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE SOFTWARE "AS IS" WITHOUT WARRANTY OF
ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO
THE QUALITY AND PERFORMANCE OF THE SOFTWARE IS WITH YOU. SHOULD THE SOFTWARE PROVE
DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR, OR CORRECTION.
IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT
HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE SOFTWARE AS PERMITTED BY
THE ABOVE LICENCE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL,
INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
SOFTWARE (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR
LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE SOFTWARE TO OPERATE WITH ANY
OTHER SOFTWARE), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
SUCH DAMAGES.
AUTHOR
Nicolas R <atoomic@cpan.org>
COPYRIGHT AND LICENSE
This software is copyright (c) 2022 by cPanel, L.L.C.
This is free software; you can redistribute it and/or modify it under the same terms as
the Perl 5 programming language system itself.