File Coverage

blib/lib/Test/Mimic.pm

Criterion	Covered	Total	%
statement	42	57	73.6
branch	9	16	56.2
condition	2	5	40.0
subroutine	8	8	100.0
pod	0	2	0.0
total	61	88	69.3

package Test::Mimic;

use strict;
use warnings;

use Test::Mimic::Library qw<
    load_records
    init_records
    load_preferences
    ARBITRARY
>;
use Test::Mimic::Generator;

our $VERSION = 0.009_007;

# Preloaded methods go here.

# Private to the Test::Mimic suite.
{
    my @pristine_INC;

    # Returns @INC to its state prior to when require_from was called.
    # Generated packages must call this before using any external modules.
    sub prepare_for_use {
        if (@pristine_INC) {
            @INC = @pristine_INC;
            @pristine_INC = ();
        }
    }

    # Accepts a package to require and a directory name to load it from.
    # This will modify @INC while it is running, but return restore it
    # prior to exiting.
    sub require_from {
        my ( $package, $dir ) = @_;

        @pristine_INC = @INC;
        @INC = ($dir);

        # Load the package
        my $success = eval( "require $package; 1" );

        # Undo the @INC change
        prepare_for_use();

        return $success;
    }
}

my $save_to;            # The directory to read/write recorded behavior.
my $recording_required; # Will be set to true iff a package was requrested that has not yet been recorded.

# See the POD below.
sub import {
    my ( $class, $user_preferences ) = @_;

    if ( ! defined($user_preferences) ) {
        die 'No preference hash reference passed to import in Test::Mimic.';
    }

    my %preferences = %{$user_preferences};

    if ( ! defined( $preferences{'packages'} ) ) {
        die 'No packages selected to mimic.';
    }

    $preferences{'test_mimic'} = ARBITRARY;
    $save_to = $preferences{'save'} ||= '.test_mimic_data';

    # Setup the library to behave per user preferences.
    my $history = $save_to . '/history_for_playback.rec';
    if ( -e $history ) { # This won't be true if we haven't recorded at all before.
        load_records($history);
    }
    else {
        init_records();
    }
    load_preferences(\%preferences);

    # Attempt to load mimicked versions of each package. Note those that have not been recorded.
    my $lib_dir = $save_to . '/lib';
    my $playback_stage = 0;
    my @to_record;
    for my $package_to_mimic ( keys %{ $preferences{'packages'} } ) {
        if ( ! require_from( $package_to_mimic, $lib_dir ) ) {
            push( @to_record, $package_to_mimic );
        }
        else {
            $playback_stage = 1;
        }
    }

    # Prevent playback/recording conflicts.
    if ( $playback_stage && @to_record > 0 ) {
        die "The playback stage and the recording stage can not coincide. Either delete the current" .
            "recordings or stop mimicking the following package(s): @to_record";
    }

    # Record the missing packages.
    if ( @to_record != 0 ) {
        $recording_required = 1;
        require Test::Mimic::Recorder;
        my %recorder_prefs = %preferences;

        #Only include those packages that need recording.
        $recorder_prefs{'packages'} = {};
        for my $package (@to_record) {
            $recorder_prefs{'packages'}->{$package} = $preferences{'packages'}->{$package};
        }
        Test::Mimic::Recorder->import(\%recorder_prefs);
    }
}

# Handles the code generation after the recording is complete.
# NOTE: This relies on the LIFO structure of END block execution.
END {
    if ($recording_required) {
        my $generator = Test::Mimic::Generator->new();
        $generator->load($save_to);
        $generator->write($save_to);
    }
}

1;
__END__