Test::MockFile(3pm)

📦
version 0.039 · 4 versions
, in ubuntu stonking

Test::MockFile(3pm) — User Contributed Perl Documentation. Manual name folded in, slay. 💖

✨ NAME ✨

Test::MockFile — Allows tests to validate code that can interact with files without touching the file system.

Okay so literally, it’s your bestie for testing file stuff without ever messing with your actual disk. Iconic. No cap.

🎀 VERSION 🎀

Version 0.039

🌸 SYNOPSIS 🌸

Intercepts file system calls for specific files so unit testing can take place without any files being altered on disk.

This is useful for small tests (the URL is https://testing.googleblog.com/2010/12/test-sizes.html) where file interaction is discouraged.

A strict mode is even provided (and turned on by default) which can throw a die when files are accessed during your tests!

# Loaded before Test::MockFile so uses the core perl functions without any hooks.
use Module::I::Dont::Want::To::Alter;

# strict mode by default
use Test::MockFile ();

# non-strict mode
use Test::MockFile qw< nostrict >;

# trace mode - logs unmocked file accesses to STDERR
use Test::MockFile qw< :trace >;

# warn mode (like strict, but warns instead of dying)
use Test::MockFile qw< warnstrict >;

# Load with one or more plugins

use Test::MockFile plugin => 'FileTemp';
use Test::MockFile plugin => [ 'FileTemp', ... ];

# Be sure to assign the output of mocks, they disappear when they go out of scope
my $foobar = Test::MockFile->file( "/foo/bar", "contents\ngo\nhere" );
open my $fh, '<', '/foo/bar' or die;    # Does not actually open the file on disk
say '/foo/bar exists' if -e $fh;
close $fh;

say '/foo/bar is a file' if -f '/foo/bar';
say '/foo/bar is THIS BIG: ' . -s '/foo/bar';

my $foobaz = Test::MockFile->file('/foo/baz');    # File starts out missing
my $opened = open my $baz_fh, '<', '/foo/baz';    # File reports as missing so fails
say '/foo/baz does not exist yet' if !-e '/foo/baz';

open $baz_fh, '>', '/foo/baz' or die;             # open for writing
print {$baz_fh} "first line\n";

open $baz_fh, '>>', '/foo/baz' or die;            # open for append.
print {$baz_fh} "second line";
close $baz_fh;

say "Contents of /foo/baz:\n>>" . $foobaz->contents() . '<<';

# Unmock your file.
# (same as the variable going out of scope
undef $foobaz;

# The file check will now happen on file system now the file is no longer mocked.
say '/foo/baz is missing again (no longer mocked)' if !-e '/foo/baz';

my $quux    = Test::MockFile->file( '/foo/bar/quux.txt', '' );
my @matches = </foo/bar/*.txt>;

# ( '/foo/bar/quux.txt' )
say "Contents of /foo/bar directory: " . join "\n", @matches;

@matches = glob('/foo/bar/*.txt');

# same as above
say "Contents of /foo/bar directory (using glob()): " . join "\n", @matches;

# Create a symlink using the builtin
my $target_mock = Test::MockFile->file('/foo/target', "data");
my $link_mock   = Test::MockFile->file('/foo/mylink');  # start as non-existent
symlink('/foo/target', '/foo/mylink');                   # now it's a symlink
say 'is a symlink!' if -l '/foo/mylink';

# Create a hard link using the builtin
my $orig_mock = Test::MockFile->file('/foo/original', "shared data");
my $hard_mock = Test::MockFile->file('/foo/hardlink');
link('/foo/original', '/foo/hardlink');
say 'hard link exists!' if -f '/foo/hardlink';

💅 IMPORT 💅

When the module is loaded with no parameters, strict mode is turned on. Any file checks, open, sysopen, opendir, stat, lstat, symlink, or link will throw a die.

For example:

use Test::MockFile;

# This will not die.
my $file    = Test::MockFile->file("/bar", "...");
my $symlink = Test::MockFile->symlink("/foo", "/bar");
-l '/foo' or print "ok\n";
open my $fh, '>', '/foo';

# All of these will die
open my $fh, '>', '/unmocked/file'; # Dies
sysopen my $fh, '/other/file', O_RDONLY;
opendir my $fh, '/dir';
-e '/file';
-l '/file';

If we want to load the module without strict mode:

use Test::MockFile qw< nostrict >;

Trace mode

Trace mode logs all unmocked file access operations to STDERR. This is useful during development to discover which files your code touches, so you know what to mock.

use Test::MockFile qw< :trace >;

Each unmocked file operation produces a line like:

[trace] open('/etc/hosts') at t/mytest.t line 42

Trace mode can be combined with nostrict to log all accesses without dying:

use Test::MockFile qw< :trace :nostrict >;

Tags may also be used without the colon prefix for backwards compatibility:

use Test::MockFile qw< trace nostrict >;

If we want to be warned about unmocked file access without dying:

use Test::MockFile qw< warnstrict >;

This is useful when migrating an existing test suite to strict mode. It allows you to discover all unmocked file accesses at once, rather than fixing them one at a time.

Relative paths are not supported:

use Test::MockFile;

# Checking relative vs absolute paths
$file = Test::MockFile->file( '/foo/../bar', '...' ); # not ok - relative path
$file = Test::MockFile->file( '/bar',        '...' ); # ok     - absolute path
$file = Test::MockFile->file( 'bar', '...' );         # ok     - current dir

🌈 authorized_strict_mode_for_package( $pkg )

Add a package namespace to the list of authorize namespaces.

authorized_strict_mode_for_package( 'Your::Package' );

🦋 file_arg_position_for_command

Args: ($command)

Provides a hint with the position of the argument most likely holding the file name for the current $command call.

This is used internaly to provide better error messages. This can be used when plugging hooks to know what's the filename we currently try to access.

💖 add_strict_rule( $command_rule, $file_rule, $action )

Args: ($command_rule, $file_rule, $action)

Add a custom rule to validate strictness mode. This is the fundation to add strict rules. You should use it, when none of the other helper to add rules work for you.

$command_rule a string or regexp or list of any to indicate which command to match $file_rule a string or regexp or undef or list of any to indicate which files your rules apply to. $action a CODE ref or scalar to handle the exception. Returning '1' skip all other rules and indicate an exception.

# Check open() on /this/file
add_strict_rule( 'open', '/this/file', sub { ... } );

# always bypass the strict rule
add_strict_rule( 'open', '/this/file', 1 );

# all available options
add_strict_rule( 'open', '/this/file', sub {
    my ($context) = @_;

    return;   # Skip this rule and continue from the next one
    return 0; # Strict violation, stop testing rules and die
    return 1; # Strict passing, stop testing rules
} );

# Disallow open(), close() on everything in /tmp/
add_strict_rule(
    [ qw< open close > ],
    qr{^/tmp}xms,
    0,
);

# Disallow open(), close() on everything (ignore filenames)
# Use add_strict_rule_for_command() instead!
add_strict_rule(
    [ qw< open close > ],
    undef,
    0,
);

🎀 clear_strict_rules()

Args: none

Clear all previously defined rules. (Mainly used for testing purpose)

✨ add_strict_rule_for_filename( $file_rule, $action )

Args: ($file_rule, $action)

Prefer using that helper when trying to add strict rules targeting files.

Apply a rule to one or more files.

add_strict_rule_for_filename( '/that/file' => sub { ... } );

add_strict_rule_for_filename( [ qw{list of files} ] => sub { ... } );

add_strict_rule_for_filename( qr{*\.t$} => sub { ... } );

add_strict_rule_for_filename( [ $dir, qr{^${dir}/} ] => 1 );

💜 add_strict_rule_for_command( $command_rule, $action )

Args: ($command_rule, $action)

Prefer using that helper when trying to add strict rules targeting specici commands.

Apply a rule to one or more files.

add_strict_rule_for_command( 'open' => sub { ... } );

add_strict_rule_for_command( [ qw{open readdir} ] => sub { ... } );

add_strict_rule_for_command( qr{open.*} => sub { ... } );

Test::MockFile::add_strict_rule_for_command(
    [qw{ readdir closedir readlink }],
    sub {
        my ($ctx) = @_;
        my $command = $ctx->{command} // 'unknown';

        warn( "Ignoring strict mode violation for $command" );
        return 1;
    }
);

🌸 add_strict_rule_generic( $action )

Args: ($action)

Prefer using that helper when adding a rule which is global and does not apply to a specific command or file.

Apply a rule to one or more files.

add_strict_rule_generic( sub { ... } );

add_strict_rule_generic( sub  {
    my ($ctx) = @_;

    my $filename = $ctx->{filename};

    return unless defined $filename;

    return 1 if UNIVERSAL::isa( $filename, 'GLOB' );

    return;
} );

🦄 is_strict_mode

Boolean helper to determine if strict mode is currently enabled.

🐚 is_warn_mode

Boolean helper to determine if warn mode is currently enabled. When warn mode is active, strict mode violations produce warnings instead of fatal errors.

👑 set_user

Args: ($uid, @gids)

Sets a mock user identity for permission checking. When set, all mocked file operations will check Unix permissions (owner/group/other) against this identity instead of the real process credentials.

The first gid in @gids is the primary group. If no gids are provided, the primary group defaults to 0.

Test::MockFile->set_user(1000, 1000);  # uid=1000, gid=1000
my $f = Test::MockFile->file('/foo', 'bar', { mode => 0600, uid => 0 });
open(my $fh, '<', '/foo') or die;  # dies: EACCES (not owner)

Test::MockFile->set_user(0, 0);  # root can read anything
open(my $fh, '<', '/foo') or die;  # succeeds

🫶 clear_user

Clears the mock user identity, disabling permission checks. File operations will succeed regardless of mode bits (the default behavior).

Test::MockFile->clear_user();

🧚 SUBROUTINES/METHODS 🧚

💖 file

Args: ($file, $contents, $stats)

This will make cause $file to be mocked in all file checks, opens, etc.

undef contents means that the file should act like it's not there. You can only set the stats if you provide content.

If you give file content, the directory inside it will be mocked as well.

my $f = Test::MockFile->file( '/foo/bar' );
-d '/foo' # not ok

my $f = Test::MockFile->file( '/foo/bar', 'some content' );
-d '/foo' # ok

See "Mock Stats" for what goes into the stats hashref.

🌟 file_from_disk 🌟

  • Args: ($file_to_mock, $file_on_disk, $stats)

okay so this one makes $file get mocked in literally every file check, open, whatever — the whole vibe. 💅

If file_on_disk isn't there? bestie, it just dies. 💀 no file, no service.

Peep "Mock Stats" if you wanna know what actually goes into that stats hashref. 👀

🦋 file_passthrough 🦋

  • Args: ($file_or_glob)

So you register a path (or a shell glob pattern) with Test::MockFile, but then all the file operations — stat, open, -f, all of it — get delegated straight to the real filesystem. The path isn't actually mocked! It's just... allowed through strict mode, so XS-based modules (hi DBD::SQLite, hi DBI 👋) that do their I/O down at the C level can create and use the file, while the Perl-level checks stay consistent. it's giving teamwork, fr.

A glob pattern (one with *, ? or [ ]) matches any path that fits the pattern. This is lowkey perfect for modules like DBD::SQLite that make lil auxiliary files next to the main database (like .db-wal, .db-shm):

use Test::MockFile;    # strict mode by default
use DBI;

# Allow the SQLite database and any auxiliary files it creates.
my $mock = Test::MockFile->file_passthrough('/tmp/test.db*');
my $dbh  = DBI->connect("dbi:SQLite:dbname=/tmp/test.db", "", "");

ok $dbh->ping,        'ping works';
ok -f '/tmp/test.db', 'file exists on disk';

And for one single, exact path:

my $mock = Test::MockFile->file_passthrough('/tmp/test.db');

When the returned object goes out of scope, the strict-mode rule gets removed — but the real file is not deleted. 😭 bestie you gotta clean up after yourself:

undef $mock;
unlink '/tmp/test.db';
  • Args: ($readlink, $file)

This makes $file mocked in all file checks, opens, etc. — same energy as always. ✨

$readlink is what "fake" file it points to. And listen: if the file $readlink points to is not mocked, it acts like a broken link — doesn't matter what's actually on disk, periodt. 💅

If $readlink is undef, then the symlink is mocked but not present. (lstat $file is empty.)

Stats can't be specified on instantiation, but in theory you can mess with them after the object exists. People don't normally touch symlink permissions tho, so like... why would you. 🙈

🧚 dir 🧚

  • Args: ($dir)

Makes $dir mocked in every file check, plus all the opendir interactions. 👑

The directory name gets normalized, so any trailing slash is removed:

$dir = Test::MockFile->dir( 'mydir/', ... ); # ok
$dir->path();                                # mydir

If there were already mocked files in the same scope, the directory will exist. Otherwise it'll be nonexistent:

my $dir = Test::MockFile->dir('/etc');
-d $dir;          # not ok since directory wasn't created yet
$dir->contents(); # undef

# Now we can create an empty directory
mkdir '/etc';
$dir_etc->contents(); # . ..

# Alternatively, we can already create files with ->file()
$dir_log  = Test::MockFile->dir('/var');
$file_log = Test::MockFile->file( '/var/log/access_log', $some_content );
$dir_log->contents(); # . .. access_log

# If you create a nonexistent file but then give it content, it will create
# the directory for you
my $file = Test::MockFile->file('/foo/bar');
my $dir  = Test::MockFile->dir('/foo');
-d '/foo'                 # false
-e '/foo/bar';            # false
$dir->contents();         # undef

$file->contents('hello');
-e '/foo/bar';            # true
-d '/foo';                # true
$dir->contents();         # . .. bar
NOTE: since . and .. are always the very first things readdir hands back, those files get auto-inserted at the front of the array. And the order of files is sorted. 🫶

Wanna mess with a directory's stat info? You gotta use the core Perl keywords, bestie. (a special helper method might show up in the future, but not today.)

$d = Test::MockFile->dir( '/foo', [], { 'mode' => 0755 } );    # dies
$d = Test::MockFile->dir( '/foo', undef, { 'mode' => 0755 } ); # dies

$d = Test::MockFile->dir('/foo');
mkdir $d, 0755;                   # ok

🌸 autovivify 🌸

When autovivify is enabled, any file operation (open, stat, rename, mkdir, etc.) on a path under the directory will automatically create a mocked file entry. This is literally made for the classic "write to a temp file then rename it into place" move. ✨

my $dir = Test::MockFile->new_dir( '/data', { 'autovivify' => 1 } );

# Files are auto-mocked when accessed -- no need to declare them
open my $fh, '>', '/data/.tmp.cfg' or die;
print $fh $config;
close $fh;
rename '/data/.tmp.cfg', '/data/config.ini';

-e '/data/config.ini';   # true

Auto-vivified files are tied to the parent directory's lifetime — when the directory mock goes out of scope, all the auto-vivified children get cleaned up too. it's giving family. 🥹

🌈 new_dir 🌈

# short form
$new_dir = Test::MockFile->new_dir( '/path' );
$new_dir = Test::MockFile->new_dir( '/path', { 'mode' => 0755 } );

# longer form 1
$dir = Test::MockFile->dir('/path');
mkdir $dir->path(), 0755;

# longer form 2
$dir = Test::MockFile->dir('/path');
mkdir $dir->path();
chmod $dir->path();

This makes a new directory with an optional mode. It's a short-hand that might be removed in the future when a stable, new interface gets introduced — so consider yourself warned. 💅

👑 Mock Stats 👑

When we create mocked files or directories, the stats default to this:

my $attrs = Test::MockFile->file( $file, $contents, {
        'dev'       => 0,            # stat[0]
        'inode'     => $next_inode,   # stat[1] - auto-assigned unique value
        'mode'      => $mode,         # stat[2]
        'nlink'     => 1,             # stat[3] - 1 for files/symlinks, 2 for dirs
        'uid'       => int $>,        # stat[4]
        'gid'       => int $),        # stat[5]
        'rdev'      => 0,             # stat[6]
        'atime'     => $now,          # stat[8]
        'mtime'     => $now,          # stat[9]
        'ctime'     => $now,          # stat[10]
        'blksize'   => 4096,          # stat[11]
        'fileno'    => undef,         # fileno()
} );

so you'll notice mode, size, and blocks are missing from that list. 👀 Mode gets set to 666 (for files) or 777 (for directories), xored against the current umask. Size and blocks get calculated from the size of contents — a.k.a. the fake file. Each mock gets its own unique inode number, and nlink defaults to 1 for files and symlinks, 2 for directories.

Wanna override one of the defaults? Just specify it when you declare the file or directory, and the rest keep defaulting like nothing happened:

my $mfile = Test::MockFile->file("/root/abc", "...", {inode => 65, uid => 123, mtime => int((2000-1970) * 365.25 * 24 * 60 * 60 }));

my $mdir = Test::MockFile->dir("/sbin", "...", { mode => 0700 }));

💜 new 💜

This class method gets called by file/symlink/dir. There is genuinely no good reason for you to call this directly. 🙈

🍓 contents 🍓

  • Optional Arg: $contents

Retrieves or updates the current contents of the file. 📖

For a directory, it only retrieves the content (as an arrayref). Wanna set directory contents? Use the file() method described above.

And symlinks? They have no contents. that's just their whole thing. 💀

⭐ read ⭐

Returns the contents of a mocked file. Dies if you call it on a directory or a symlink. 😤

In scalar context it hands you the whole file contents as one single string. In list context it splits the contents into lines using $/ as the input record separator (keeping the separator in each element), consistent with Perl's readline behavior.

Returns undef in scalar context (or an empty list in list context) if the file doesn't currently exist.

my $bar  = Test::MockFile->file( '/foo/bar', "line1\nline2\n" );
my $text = $bar->read;     # "line1\nline2\n"
my @lines = $bar->read;    # ( "line1\n", "line2\n" )

🎀 write 🎀

Sets the contents of a mocked file. Dies if called on a directory or symlink. 💀

Multiple arguments get concatenated. And if the file doesn't currently exist, calling write literally brings it into existence — main character energy. ✨

Returns the mock object so you can chain. 💅

my $bar = Test::MockFile->file( '/foo/bar' );  # non-existent file
$bar->write("hello world");                     # now exists
$bar->write("line1\n", "line2\n");              # concatenated

🦋 append 🦋

Appends to the contents of a mocked file. Dies if called on a directory or symlink. 💀

Multiple arguments get concatenated before appending. If the file doesn't exist yet, calling append brings it into existence (as if you were writing to an empty file).

Returns the mock object for chaining, ofc. 🫶

my $bar = Test::MockFile->file( '/foo/bar', "first\n" );
$bar->append("second\n");                        # "first\nsecond\n"
$bar->append("third\n", "fourth\n");             # concatenated

🌸 filename 🌸

Deprecated. Same as path. it's giving legacy, bestie. 🫠

✨ path ✨

The path (filename or dirname) of the file or directory this mock object is controlling. simple as that. 💅

Makes the virtual file go away. NOTE: this also works for directories. gone, deleted, not here anymore. 👋

🔥 touch 🔥

  • Optional Args: ($epoch_time)

Acts like the UNIX utility touch. It sets atime, mtime, and ctime to $epoch_time.

If you pass no arguments, $epoch_time is set to time(). And if the file doesn't exist? Contents get set to an empty string. 🫶

🌟 stat 🌟

Returns the stat of a mocked file. (It does not follow symlinks.)

  • Optional Arg: $readlink

Returns the stat of a mocked file. (It does not follow symlinks.) You can also use this to change what your symlink is pointing to. 🪄

returns true/false depending on whether this object is a symlink.

🌸 is_dir 🌸

returns true/false depending on whether this object is a directory.

🎀 is_file 🎀

returns true/false depending on whether this object is a regular file.

⭐ size ⭐

returns the size of the file, based on its contents.

💜 exists 💜

returns true or false based on if the file exists right now. vibe check, but for files. 👀

🍓 blocks 🍓

Calculates the block count of the file based on its size.

🦋 chmod 🦋

  • Optional Arg: $perms

Lets you alter the permissions of a file. This only changes the 07777 bits of the file permissions. And heads up — the number you pass should be in octal 0755 form, not the alphabetic "755" form. 😤 get it right bestie.

👑 permissions 👑

Returns the permissions of the file.

💅 mtime 💅

  • Optional Arg: $new_epoch_time

Returns — and optionally sets — the mtime of the file if you pass it as an integer.

✨ ctime ✨

  • Optional Arg: $new_epoch_time

Returns — and optionally sets — the ctime of the file if you pass it as an integer.

🌟 atime 🌟

  • Optional Arg: $new_epoch_time

Returns — and optionally sets — the atime of the file if you pass it as an integer.

🔥 add_file_access_hook 🔥

  • Args: ( $code_ref )

You can use add_file_access_hook to add a code ref that gets called every single time a real file operation happens — and by "real" we mean not mocked, okay? 🫶 We use this for strict mode so we can die the moment we detect your program is unexpectedly touching files. But like, you're also totally welcome to use it for whatever you want. It's your world. 👑

Whenever that code ref gets called, we hand it 2 arguments: $code->($access_type, $at_under_ref). Heads up though — if you alter the variables inside $at_under_ref, that will affect the variables passed to open / sysopen, etc. So, y'know, be careful with the vibes you're messing with. 😭

One use might be:

Test::MockFile::add_file_access_hook(sub { my $type = shift; print "$type called at: " . Carp::longmess() } );

clear_file_access_hooks 🧹✨

Calling this subroutine will clear everything that was passed to add_file_access_hook. Poof. Gone. Clean slate, bestie. 🎀

How this mocking is done 🪄

Test::MockFile uses 2 methods to mock file access:

-X via Overload::FileCheck 🔍

It is currently not possible in pure perl to override stat, lstat and -X operators. (Like, fr fr, perl just doesn't play that way. 😤)

In conjunction with this module, we've developed Overload::FileCheck. 💅

This enables us to intercept calls to stat, lstat and -X operators (like -e, -f, -d, -s, etc.) and pass them to our control. If the file is currently being mocked, we return the stat (or lstat) information on the file to be used to determine the answer to whatever check was made. This even works for things like -e _. If we do not control the file in question, we return FALLBACK_TO_REAL_OP() which then makes a normal check. Real ones get real answers. 🌈

CORE::GLOBAL:: overrides 🔥

Since 5.10, it has been possible to override function calls by defining them, like:

*CORE::GLOBAL::open = sub(*;$@) {...}

Any code which is loaded AFTER this happens will use the alternate open. This means you can place your use Test::MockFile statement after statements you don't want to be mocked and there is no risk that the code will ever be altered by Test::MockFile. Iconic behaviour, honestly. 👑

We oveload the following statements and then return tied handles to enable the rest of the IO functions to work properly. Only open / sysopen are needed to address file operations. However opendir file handles were never setup for tie so we have to override all of opendir's related functions.

  • open
  • sysopen
  • opendir
  • readdir
  • telldir
  • seekdir
  • rewinddir
  • closedir

🌸 CAVEATS AND LIMITATIONS 🌸

DEBUGGER UNDER STRICT MODE 😭

If you want to use the Perl debugger (perldebug) on any code that uses Test::MockFile in strict mode, you will need to load Term::ReadLine beforehand, because it loads a file. Under the debugger, the debugger will load the module after Test::MockFile and get mad. 🙈

# Load it from the command line
perl -MTerm::ReadLine -d code.pl

# Or alternatively, add this to the top of your code:
use Term::ReadLine

The link() override copies file contents and metadata from the source to the destination mock. However, unlike real hard links, writes to one file will not be reflected in the other. The "nlink" count is incremented on both files.

The destination path must be a pre-declared mock (via file() or dir()). Attempting to link() a mocked source to an unmocked destination will fail with "EXDEV". No cap. 💀

FILENO IS UNSUPPORTED 🙅‍♀️

Filehandles can provide the file descriptor (in number) using the "fileno" keyword but this is purposefully unsupported in Test::MockFile.

The reason is that by mocking a file, we're creating an alternative file system. Returning a "fileno" (file descriptor number) would require creating file descriptor numbers that would possibly conflict with the file descriptors you receive from the real filesystem.

In short, this is a recipe for buggy tests or worse — truly destructive behavior. If you have a need for a real file, we suggest File::Temp. Bestie, just use the real thing. 🍓

BAREWORD FILEHANDLE FAILURES 😵‍💫

There is a particular type of bareword filehandle failures that cannot be fixed.

These errors occur because there's compile-time code that uses bareword filehandles in a function call that cannot be expressed by this module's prototypes for core functions.

The only solution to these is loading Test::MockFile after the other code:

This will fail:

# This will fail because Test2::V0 will eventually load Term::Table::Util
# which calls open() with a bareword filehandle that is misparsed by this module's
# opendir prototypes
use Test::MockFile ();
use Test2::V0;

This will succeed:

# This will succeed because open() will be parsed by perl
# and only then we override those functions
use Test2::V0;
use Test::MockFile ();

(Using strict-mode will not fix it, even though you should use it.) 🎀

AUTHOR ✍️

Todd Rinaldo, "<toddr at cpan.org>"

BUGS 🐛

Please report any bugs or feature requests to https://github.com/cpanel/Test-MockFile.

SUPPORT 🫶

You can find documentation for this module with the perldoc command.

perldoc Test::MockFile

You can also look for information at:

  • CPAN Ratings

https://cpanratings.perl.org/d/Test-MockFile

  • Search CPAN

https://metacpan.org/release/Test-MockFile

ACKNOWLEDGEMENTS 💖

Thanks to Nicolas R., "<atoomic at cpan.org>" for help with Overload::FileCheck. This module could not have been completed without it. Literally could not. Main character energy from Nicolas. 👑

Copyright 2018 cPanel L.L.C.

All rights reserved.

http://cpanel.net

This is free software; you can redistribute it and/or modify it under the same terms as Perl itself. See perlartistic.

and that's the whole page, bestie!! 🎀✨ this lil masterpiece is Test::MockFile(3pm), sitting at perl v5.40.1, dated 2026-03-27 — go forth and mock responsibly, you absolute legend 💅🦋

📦 where this page comes from