README

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

VERSION
    Version 0.038

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
    <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)"

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

    If "file_on_disk" isn't present, then this will die.

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

  file_passthrough
    Args: "($file_or_glob)"

    Registers a path (or shell glob pattern) with Test::MockFile but
    delegates all file operations ("stat", "open", "-f", etc.) to the real
    filesystem. The path is not actually mocked: it is simply allowed
    through strict mode so that XS-based modules (e.g. DBD::SQLite, DBI)
    that perform C-level I/O can create and use the file while Perl-level
    checks remain consistent.

    A glob pattern (containing "*", "?" or "[""]") matches any path that
    fits the pattern. This is useful for modules like DBD::SQLite that
    create auxiliary files alongside the main database (e.g. ".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';

    For a single, exact path:

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

    When the returned object goes out of scope, the strict-mode rule is
    removed but the real file is not deleted. Clean up the file yourself if
    needed:

        undef $mock;
        unlink '/tmp/test.db';

  symlink
    Args: ($readlink, $file )

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

    $readlink indicates what "fake" file it points to. If the file $readlink
    points to is not mocked, it will act like a broken link, regardless of
    what's on disk.

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

    Stats are not able to be specified on instantiation but can in theory be
    altered after the object is created. People don't normally mess with the
    permissions on a symlink.

  dir
    Args: ($dir)

    This will cause $dir to be mocked in all file checks, and "opendir"
    interactions.

    The directory name is normalized so any trailing slash is removed.

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

    If there were previously mocked files (within the same scope), the
    directory will exist. Otherwise, the directory will 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: Because "." and ".." will always be the first things "readdir"
    returns, These files are automatically inserted at the front of the
    array. The order of files is sorted.

    If you want to affect the stat information of a directory, you need to
    use the available core Perl keywords. (We might introduce a special
    helper method for it in the future.)

        $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 supports the common pattern of writing to a temp
    file and renaming it into place.

        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 auto-vivified children are
    cleaned up.

  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 creates a new directory with an optional mode. This is a short-hand
    that might be removed in the future when a stable, new interface is
    introduced.

  Mock Stats
    When creating mocked files or directories, we default their stats to:

        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()
        } );

    You'll notice that mode, size, and blocks have been left out of this.
    Mode is set to 666 (for files) or 777 (for directories), xored against
    the current umask. Size and blocks are calculated based on the size of
    'contents' a.k.a. the fake file. Each mock is assigned a unique inode
    number, and nlink defaults to 1 for files and symlinks, 2 for
    directories.

    When you want to override one of the defaults, all you need to do is
    specify that when you declare the file or directory. The rest will
    continue to default.

        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 is called by file/symlink/dir. There is no good reason
    to call this directly.

  contents
    Optional Arg: $contents

    Retrieves or updates the current contents of the file.

    Only retrieves the content of the directory (as an arrayref). You can
    set directory contents with calling the "file()" method described above.

    Symlinks have no contents.

  read
    Returns the contents of a mocked file. Dies if called on a directory or
    symlink.

    In scalar context, returns the entire file contents as a single string.
    In list context, splits the contents into lines using $/ as the input
    record separator (preserving 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 does not 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 are concatenated. If the file does not currently
    exist, calling "write" brings it into existence.

    Returns the mock object for chaining.

        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 are concatenated before appending. If the file does
    not currently exist, calling "append" brings it into existence (as if
    writing to an empty file).

    Returns the mock object for chaining.

        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".

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

  unlink
    Makes the virtual file go away. NOTE: This also works for directories.

  touch
    Optional Args: ($epoch_time)

    This function acts like the UNIX utility touch. It sets atime, mtime,
    ctime to $epoch_time.

    If no arguments are passed, $epoch_time is set to time(). If the file
    does not exist, contents are set to an empty string.

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

  readlink
    Optional Arg: $readlink

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

  is_link
    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.

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

  chmod
    Optional Arg: $perms

    Allows you to alter the permissions of a file. This only allows you to
    change the 07777 bits of the file permissions. The number passed should
    be the octal 0755 form, not the alphabetic "755" form

  permissions
    Returns the permissions of the file.

  mtime
    Optional Arg: $new_epoch_time

    Returns and optionally sets the mtime of the file if passed as an
    integer.

  ctime
    Optional Arg: $new_epoch_time

    Returns and optionally sets the ctime of the file if passed as an
    integer.

  atime
    Optional Arg: $new_epoch_time

    Returns and optionally sets the atime of the file if passed 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 time a real file (not mocked) operation happens. We use this for
    strict mode to die if we detect your program is unexpectedly accessing
    files. You are welcome to use it for whatever you like.

    Whenever the code ref is called, we pass 2 arguments:
    "$code->($access_type, $at_under_ref)". Be aware that altering the
    variables in $at_under_ref will affect the variables passed to open /
    sysopen, etc.

    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

  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
    <http://perldoc.perl.org/functions/stat.html>, lstat
    <http://perldoc.perl.org/functions/lstat.html> and -X operators
    <http://perldoc.perl.org/functions/-X.html>. 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.

   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.

    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

  HARD LINKS
    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".

  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.

  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.

LICENSE AND COPYRIGHT
    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.