my
$CLASS
=
'Test2::API::InterceptResult'
;
tests
construction
=>
sub
{
my
$one
=
$CLASS
->new(
'a'
);
ok(
$one
->isa(
$CLASS
),
"Got an instance"
);
is(reftype(
$one
),
'ARRAY'
,
"Blessed arrayref"
);
is_deeply(
$one
, [
'a'
],
"Ref looks good."
);
my
$two
=
$CLASS
->new_from_ref([
'a'
]);
ok(
$two
->isa(
$CLASS
),
"Got an instance"
);
is(reftype(
$two
),
'ARRAY'
,
"Blessed arrayref"
);
is_deeply(
$two
, [
'a'
],
"Ref looks good."
);
my
$three
=
$two
->clone;
ok(
$three
->isa(
$CLASS
),
"Got an instance"
);
is(reftype(
$three
),
'ARRAY'
,
"Blessed arrayref"
);
is_deeply(
$three
, [
'a'
],
"Ref looks good."
);
push
@$two
=>
'b'
;
is_deeply(
$two
, [
'a'
,
'b'
],
"Modified two"
);
is_deeply(
$three
, [
'a'
],
"three was not changed"
);
my
$four
= intercept {
ok(1,
"Pass"
);
};
ok(
$four
->isa(
$CLASS
),
"Intercept returns an instance"
);
};
tests
event_list
=>
sub
{
my
$one
=
$CLASS
->new(
'a'
,
'b'
);
is_deeply([
$one
->event_list], [
'a'
,
'b'
],
"event_list is essentially \@{\$self}"
);
};
tests
_upgrade
=>
sub
{
my
$event
= Test2::Event::Pass->new(
name
=>
'soup for you'
,
trace
=> {
frame
=> [
'foo'
,
'foo.pl'
, 42]});
ok(
$event
->isa(
'Test2::Event'
),
"Start with an event"
);
my
$one
=
$CLASS
->new;
my
$up
=
$one
->_upgrade(
$event
);
ok(
$up
->isa(
'Test2::API::InterceptResult::Event'
),
"Upgraded the event"
);
is(
$up
->result_class,
$CLASS
,
"set the result class"
);
is_deeply(
$event
->facet_data,
$up
->facet_data,
"Facet data is identical"
);
$up
->facet_data->{trace}->{frame}->[2] = 43;
is(
$up
->trace_line, 43,
"Modified the facet data in the upgraded clone"
);
is(
$event
->facet_data->{trace}->{frame}->[2], 42,
"Did nto modify the original"
);
my
$up2
=
$one
->_upgrade(
$up
);
is(
"$up2"
,
"$up"
,
"Returned the ref unmodified because it is already an upgraded item"
);
my
$subtest
=
'Test2::Event::V2'
->new(
trace
=> {
frame
=> [
'foo'
,
'foo.pl'
, 42]},
assert
=> {
pass
=> 1,
details
=>
'pass'
},
parent
=> {
hid
=> 1,
children
=> [
$event
],
},
);
my
$subup
=
$one
->_upgrade(
$subtest
);
ok(
$subup
->the_subtest->{children}->isa(
$CLASS
),
"Blessed subtest subevents"
);
ok(
$subup
->the_subtest->{children}->[0]->isa(
'Test2::API::InterceptResult::Event'
),
"Upgraded the children"
);
};
tests
hub
=>
sub
{
my
$one
= intercept {
ok(1,
"pass"
);
ok(0,
"fail"
);
plan 2;
};
my
$hub
=
$one
->hub;
ok(
$hub
->isa(
'Test2::Hub'
),
"Hub is a proper instance"
);
ok(
$hub
->check_plan,
"Had a plan and followed it"
);
is(
$hub
->count, 2,
"saw both events"
);
is(
$hub
->failed, 1,
"saw a failure"
);
ok(
$hub
->ended,
"Hub ended"
);
is_deeply(
$one
->state,
{
count
=> 2,
failed
=> 1,
is_passing
=> 0,
plan
=> 2,
bailed_out
=>
undef
,
skip_reason
=>
undef
,
follows_plan
=> 1,
},
"Got the hub state"
);
};
tests
upgrade
=>
sub
{
my
$one
= intercept {
Test::More::ok(1,
"pass"
);
Test::More::ok(1,
"pass"
);
};
ok(
$one
->[0]->isa(
'Test2::Event::Ok'
),
"Original event is not upgraded 0"
);
ok(
$one
->[1]->isa(
'Test2::Event::Ok'
),
"Original event is not upgraded 1"
);
my
$two
=
$one
->upgrade;
ok(
$one
->[0]->isa(
'Test2::Event::Ok'
),
"Did not modify original 0"
);
ok(
$one
->[0]->isa(
'Test2::Event::Ok'
),
"Did not modify original 1"
);
ok(
$two
->[0]->isa(
'Test2::API::InterceptResult::Event'
),
"Upgraded copy 0"
);
ok(
$two
->[1]->isa(
'Test2::API::InterceptResult::Event'
),
"Upgraded copy 1"
);
my
$three
=
$two
->upgrade;
ok(
"$two->[0]"
ne
"$three->[0]"
,
"Upgrade on an already upgraded instance returns copies of the events, not originals"
);
like(
exception {
$one
->upgrade() },
qr/Called a method that creates a new instance in void context/
,
"Calling upgrade() without keeping the result is a bug"
);
$one
->upgrade(
in_place
=> 1);
ok(
$one
->[0]->isa(
'Test2::API::InterceptResult::Event'
),
"Upgraded in place 0"
);
ok(
$one
->[1]->isa(
'Test2::API::InterceptResult::Event'
),
"Upgraded in place 1"
);
};
tests
squash_info
=>
sub
{
my
$one
= intercept {
diag
"isolated 1"
;
note
"isolated 2"
;
sub
{
my
$ctx
= context();
diag
"inline 1"
;
note
"inline 2"
;
$ctx
->fail;
diag
"inline 3"
;
note
"inline 4"
;
$ctx
->release;
}->();
diag
"isolated 3"
;
note
"isolated 4"
;
};
my
$new
=
$one
->squash_info;
$one
->squash_info(
in_place
=> 1);
is_deeply(
$new
,
$one
,
"Squash and squash in place produce the same result"
);
is(
@$one
, 5,
"5 events after squash"
);
is_deeply([
$one
->[0]->info_messages], [
'isolated 1'
],
"First event not modified"
);
is_deeply([
$one
->[1]->info_messages], [
'isolated 2'
],
"Second event not modified"
);
is_deeply([
$one
->[3]->info_messages], [
'isolated 3'
],
"second to last event not modified"
);
is_deeply([
$one
->[4]->info_messages], [
'isolated 4'
],
"last event not modified"
);
is_deeply(
[
$one
->[2]->info_messages],
[
'inline 1'
,
'inline 2'
,
'inline 3'
,
'inline 4'
,
],
"Assertion collected info generated in the same context"
);
ok(
$one
->[2]->has_assert,
"Assertion is still an assertion"
);
my
$two
= intercept {
};
};
tests
messages
=>
sub
{
my
$one
= intercept {
note
"foo"
;
diag
"bar"
;
ok(1);
sub
{
my
$ctx
= context();
$ctx
->send_ev2(
errors
=> [
{
tag
=>
'error'
,
details
=>
"Error 1"
},
{
tag
=>
'error'
,
details
=>
"Error 2"
},
],
info
=> [
{
tag
=>
'DIAG'
,
details
=>
'Diag 1'
},
{
tag
=>
'DIAG'
,
details
=>
'Diag 2'
},
{
tag
=>
'NOTE'
,
details
=>
'Note 1'
},
{
tag
=>
'NOTE'
,
details
=>
'Note 2'
},
],
);
$ctx
->release;
}->();
note
"baz"
;
diag
"bat"
;
};
is_deeply(
$one
->diag_messages,
[
'bar'
,
'Diag 1'
,
'Diag 2'
,
'bat'
],
"Got diags"
);
is_deeply(
$one
->note_messages,
[
'foo'
,
'Note 1'
,
'Note 2'
,
'baz'
],
"Got Notes"
);
is_deeply(
$one
->error_messages,
[
'Error 1'
,
'Error 2'
],
"Got errors"
);
};
tests
grep
=>
sub
{
my
$one
= intercept {
ok(1),
note
"A Note"
;
diag
"A Diag"
;
tests
foo
=>
sub
{ ok(1) };
sub
{
my
$ctx
= context();
$ctx
->send_ev2(
errors
=> [{
tag
=>
'error'
,
details
=>
"Error 1"
}]);
$ctx
->release;
}->();
plan 2;
};
$one
->upgrade(
in_place
=> 1);
is_deeply(
$one
->asserts, [
$one
->[0],
$one
->[3]],
"Got the asserts"
);
is_deeply(
$one
->subtests, [
$one
->[3]],
"Got the subtests"
);
is_deeply(
$one
->diags, [
$one
->[2]],
"Got the diags"
);
is_deeply(
$one
->notes, [
$one
->[1]],
"Got the notes"
);
is_deeply(
$one
->errors, [
$one
->[4]],
"Got the errors"
);
is_deeply(
$one
->plans, [
$one
->[5]],
"Got the plans"
);
$one
->asserts(
in_place
=> 1);
is(
@$one
, 2,
"2 events"
);
ok(
$_
->has_assert,
"Is an assert"
)
for
@$one
;
};
tests
map
=>
sub
{
my
$one
= intercept { ok(1); ok(2) };
$one
->upgrade(
in_place
=> 1);
is_deeply(
$one
->flatten,
[
$one
->[0]->flatten,
$one
->[1]->flatten ],
"Flattened both events"
);
is_deeply(
$one
->briefs,
[
$one
->[0]->brief,
$one
->[1]->brief ],
"Brief of both events"
);
is_deeply(
$one
->summaries,
[
$one
->[0]->summary,
$one
->[1]->summary ],
"Summaries of both events"
);
my
$two
= intercept {
tests
foo
=>
sub
{ ok(1) };
ok(1);
tests
bar
=>
sub
{ ok(1) };
}->upgrade;
is_deeply(
$two
->subtest_results,
[
$two
->[0]->subtest_result,
$two
->[2]->subtest_result ],
"Got subtest results"
);
};
done_testing;