Test::Mock::HTTP::Tiny's set_mocked_data() expects an arrayref or a hashref. You are providing it with a scalar (string).

The captured data is indeed an arrayref as Test::Mock::HTTP::Tiny->captured_data_dump shows. But what you save to a file is a text representation of a Perl data structure. What you get when you read that data back from file is a scalar string. And that's what you pass to Test::Mock::HTTP::Tiny's set_mocked_data() which silently ignores you!

You need to "undump" the file contents somehow and resurrect the Perl data structure you started with. The simplest way to achieve this is by eval()'ing the text representation minus the $VAR1 = at the beginning of the string (placed there by Data::Dumper) (see the warnings at the end of this post):

$replay =~ s/^\$VAR1\s*=\s*//;
$replay = eval $replay; 
print "ref: ".ref($replay)."\n";
Test::Mock::HTTP::Tiny->set_mocked_data($replay);
[download]

You were unlucky in debugging -- in the source code of Test::Mock::HTTP::Tiny I see this:

    if (ref($new_mocked_data) eq 'ARRAY') {
      ...
    elsif (ref($new_mocked_data) eq 'HASH') {
      ...
    else {
        # TODO: error
    }
[download]

Apropos HTTP mocking, https://blogs.perl.org/users/e_choroba/2016/01/post.html by choroba presents an alternative.

WARNING: Be warned that eval()'ing things from files is a huge security hole. An alternative would be to use Storable to dump/freeze and resurrect/thaw a Perl data structure. But it too has boldface security warnings:

my $mocked_data = Test::Mock::HTTP::Tiny->mocked_data();
store $mocked_data, 'mock_html.dat';
...
my $replay = retrieve 'mock_html.dat';
print "ref: ".ref($replay)."\n";
Test::Mock::HTTP::Tiny->set_mocked_data($replay);
[download]

bw, bliako

You need to "undump" the file contents somehow and resurrect the Perl data structure you started with. The simplest way to achieve this is by eval()'ing the text representation minus the $VAR1 = at the beginning of the string (placed there by Data::Dumper) (see the warnings at the end of this post):

Shameless plug: For many data structures, it's possible to do this more safely via my Data::Undump::PPI (see the disclaimer in Config::Perl).

However, looking at the source, it would seem the simpler solution is to just serialize Test::Mock::HTTP::Tiny->captured_data oneself in a more suitable format, perhaps JSON or YAML (AFAICT from looking at the source, the data structure doesn't look like it contains Perl objects that would pervent serialization, though at the moment I don't have the time to test).

it would seem the simpler solution is to just serialize ...

yep, good point haukex++ as this is the easiest and most secure by far. Since I have more time:

use strict;
use warnings;

use HTTP::Tiny;
use Test::Mock::HTTP::Tiny;
use JSON;

my $http = HTTP::Tiny->new;
my $resp = $http->get('http://www.way-finder.uk/');

# EDIT: it's captured_data() not mocked_data() see below
#my $json_str = eval { JSON::encode_json(Test::Mock::HTTP::Tiny->mocke
+d_data()) };
my $json_str = eval { JSON::encode_json(Test::Mock::HTTP::Tiny->captur
+ed_data()) };
die "failed to encode json" if $@;

open my $fh, '>', 'mock_html.dat';
print $fh $json_str;
close $fh;
[download]

and

use strict;
use warnings;
use Test::More;
use Test::Mock::HTTP::Tiny;

use WWW::Crawl;
use JSON;
plan tests => 1;

$/ = undef;
open my $fh, '<', 't/mock_html.dat' or die "Can't open datafile";
my $replay = <$fh>;
close $fh;

$replay = eval { JSON::decode_json($replay) };
ok(!$@, "parsed JSON replay data") or BAIL_OUT($@);
is(ref($replay), 'ARRAY', "parsed JSON replay data is an ARRAY");

die "Nothing to replay" unless $replay;

Test::Mock::HTTP::Tiny->set_mocked_data($replay);

my $crawl = WWW::Crawl->new(
    'timestamp' => 'a',
);

my @links = $crawl->crawl('https://www.testing.crawl', \&link);

cmp_ok ( scalar @links, '==', 8, 'Correct link count');

sub link {
    diag ($_[0]);
}
[download]

note: eval() around JSON subs is because it dies on error last time I checked.

bw, bliako

You were unlucky in debugging

* kicks self *

I looked at the source code and didn't pick that up...I must have been tired or having a senior moment!

But, it begs the question...
Should I be using this module at all?

• It hasn't been updated in 8 years
• It's unlikely to be on the target machine
• It's only used for testing
• Its documentation is virtually non-existant
• It appears unfinished

I try not to get users to install non-core modules unless really necessary. Especially for testing.

Be warned that eval()'ing things from files is a huge security hole

Is this perhaps a security hole worth accepting because it is only used in testing? So the input file is known and anyone changing the file would be potentially sabotaging themself.

You need to "undump" the file contents somehow and resurrect the Perl data structure you started with

This sounds like the perfect use for a JSON object, especially as JSON::PP is core...

Apropos HTTP mocking, https://blogs.perl.org/users/e_choroba/2016/01/post.html by choroba presents an alternative

Ah yes...
choroba shared that article when I was struggling with testing Business::Stripe::WebCheckout. I read it a few times but didn't understand it...I recall being totally in awe.

I must revisit it again having gained a couple of years extra knowledge and experience. Thanks for bringing it back to my attention.

G'day Bod,

Not an answer to your question but a heads-up regarding a security vulnerability with HTTP::Tiny: CVE-2023-31486.

The module documentation discusses this. Two of the easiest fixes would be:

# Change
use HTTP::Tiny;
# to
use HTTP::Tiny 0.083;
[download]

or

# Change
my $http = HTTP::Tiny->new;
# to
my $http = HTTP::Tiny->new(verify_SSL => 1);
[download]

Thanks Ken,

I've changed to use HTTP::Tiny 0.083; and also set this as the minimum version in Makefile.PL