MAN page from OpenSuSE perl-Perlito5-9.028-lp156.4.1.noarch.rpm

Perlito5X::Test2::API::Context

Section: User Contributed Perl Documentation (3)
Updated: 2024-12-05
Index

NAME

Test2::API::Context - Object to represent a testing context.

DESCRIPTION

The context object is the primary interface for authors of testing toolswritten with Test2. The context object represents the context inwhich a test takes place (File and Line Number), and provides a quick way togenerate events from that context. The context object also takes care ofsending events to the correct Test2::Hub instance.

SYNOPSIS

In general you will not be creating contexts directly. To obtain a context youshould always use "context()" which is exported by the Test2::API module.

    use Test2::API qw/context/;    sub my_ok {        my ($bool, $name) = @_;        my $ctx = context();        $ctx->ok($bool, $name);        $ctx->release; # You MUST do this!        return $bool;    }

Context objects make it easy to wrap other tools that also use context. Onceyou grab a context, any tool you call before releasing your context willinherit it:

    sub wrapper {        my ($bool, $name) = @_;        my $ctx = context();        $ctx->diag("wrapping my_ok");        my $out = my_ok($bool, $name);        $ctx->release; # You MUST do this!        return $out;    }

CRITICAL DETAILS

you MUST always use the context() sub from Test2::API

Creating your own context via "Test2::API::Context->new()" will almost neverproduce a desirable result. Use "context()" which is exported by Test2::API.

There are a handful of cases where a tool author may want to create a newcontext by hand, which is why the "new" method exists. Unless you really knowwhat you are doing you should avoid this.

You MUST always release the context when done with it

Releasing the context tells the system you are done with it. This gives it achance to run any necessary callbacks or cleanup tasks. If you forget torelease the context it will try to detect the problem and warn you about it.

You MUST NOT pass context objects around

When you obtain a context object it is made specifically for your tool and anytools nested within. If you pass a context around you run the risk of pollutingother tools with incorrect context information.

If you are certain that you want a different tool to use the same context youmay pass it a snapshot. "$ctx->snapshot" will give you a shallow clone ofthe context that is safe to pass around or store.

You MUST NOT store or cache a context for later

As long as a context exists for a given hub, all tools that try to get acontext will get the existing instance. If you try to store the context youwill pollute other tools with incorrect context information.

If you are certain that you want to save the context for later, you can use asnapshot. "$ctx->snapshot" will give you a shallow clone of the contextthat is safe to pass around or store.

"context()" has some mechanisms to protect you if you do cause a context topersist beyond the scope in which it was obtained. In practice you should notrely on these protections, and they are fairly noisy with warnings.

You SHOULD obtain your context as soon as possible in a given tool

You never know what tools you call from within your own tool will need acontext. Obtaining the context early ensures that nested tools can find thecontext you want them to find.

METHODS

$ctx->done_testing;

Note that testing is finished. If no plan has been set this will generate aPlan event.

$clone = $ctx->snapshot()

This will return a shallow clone of the context. The shallow clone is safe tostore for later.

$ctx->release()

This will release the context. This runs cleanup tasks, and several importanthooks. It will also restore $!, $?, and $@ to what they were when thecontext was created.

Note: If a context is acquired more than once an internal refcount is kept."release()" decrements the ref count, none of the other actions of"release()" will occur unless the refcount hits 0. This means only the lastcall to "release()" will reset $?, $!, $@,and run the cleanup tasks.

$ctx->throw($message)

This will throw an exception reporting to the file and line number of thecontext. This will also release the context for you.

$ctx->alert($message)

This will issue a warning from the file and line number of the context.

$stack = $ctx->stack()

This will return the Test2::API::Stack instance the context used to findthe current hub.

$hub = $ctx->hub()

This will return the Test2::Hub instance the context recognizes as thecurrent one to which all events should be sent.

$dbg = $ctx->trace()

This will return the Test2::Util::Trace instance used by the context.

$ctx->do_in_context(\&code, @args);

Sometimes you have a context that is not current, and you want things to use itas the current one. In these cases you can call"$ctx->do_in_context(sub { ... })". The codeblock will be run, andanything inside of it that looks for a context will find the one on which themethod was called.

This DOES NOT affect context on other hubs, only the hub used by the contextwill be affected.

    my $ctx = ...;    $ctx->do_in_context(sub {        my $ctx = context(); # returns the $ctx the sub is called on    });

Note: The context will actually be cloned, the clone will be used instead ofthe original. This allows the thread id, process id, and error variables to be correct withoutmodifying the original context.

$ctx->restore_error_vars()

This will set $!, $?, and $@ to what they were when the context wascreated. There is no localization or anything done here, calling this methodwill actually set these vars.

$! = $ctx->errno()

The (numeric) value of $! when the context was created.

$? = $ctx->child_error()

The value of $? when the context was created.

$@ = $ctx->eval_error()

The value of $@ when the context was created.

EVENT PRODUCTION METHODS

$event = $ctx->ok($bool, $name)

$event = $ctx->ok($bool, $name, \@on_fail)

This will create an Test2::Event::Ok object for you. If $bool is falsethen an Test2::Event::Diag event will be sent as well with details about thefailure. If you do not want automatic diagnostics you should use the"send_event()" method directly.

The third argument "\@on_fail") is an optional set of diagnostics to be sent inthe event of a test failure. Plain strings will be sent asTest2::Event::Diag events. References will be used to constructTest2::Event::Info events with "diagnostics => 1".

$event = $ctx->info($renderer, diagnostics => $bool, %other_params)

Send an Test2::Event::Info.

$event = $ctx->note($message)

Send an Test2::Event::Note. This event prints a message to STDOUT.

$event = $ctx->diag($message)

Send an Test2::Event::Diag. This event prints a message to STDERR.

$event = $ctx->plan($max)

$event = $ctx->plan(0, 'SKIP', $reason)

This can be used to send an Test2::Event::Plan event. This eventusually takes either a number of tests you expect to run. Optionally you canset the expected count to 0 and give the 'SKIP' directive with a reason tocause all tests to be skipped.

$event = $ctx->skip($name, $reason);

Send an Test2::Event::Skip event.

$event = $ctx->bail($reason)

This sends an Test2::Event::Bail event. This event will completelyterminate all testing.

$event = $ctx->send_event($Type, %parameters)

This lets you build and send an event of any type. The $Type argument shouldbe the event package name with "Test2::Event::" left off, or a fullyqualified package name prefixed with a '+'. The event is returned after it issent.

    my $event = $ctx->send_event('Ok', ...);

    my $event = $ctx->send_event('+Test2::Event::Ok', ...);

$event = $ctx->build_event($Type, %parameters)

This is the same as "send_event()", except it builds and returns the eventwithout sending it.

HOOKS

There are 2 types of hooks, init hooks, and release hooks. As the namessuggest, these hooks are triggered when contexts are created or released.

INIT HOOKS

These are called whenever a context is initialized. That means when a newinstance is created. These hooks are NOT called every time somethingrequests a context, just when a new one is created.

GLOBAL

This is how you add a global init callback. Global callbacks happen for everycontext for any hub or stack.

    Test2::API::test2_add_callback_context_init(sub {        my $ctx = shift;        ...    });

PER HUB

This is how you add an init callback for all contexts created for a given hub.These callbacks will not run for other hubs.

    $hub->add_context_init(sub {        my $ctx = shift;        ...    });

PER CONTEXT

This is how you specify an init hook that will only run if your call to"context()" generates a new context. The callback will be ignored if"context()" is returning an existing context.

    my $ctx = context(on_init => sub {        my $ctx = shift;        ...    });

RELEASE HOOKS

These are called whenever a context is released. That means when the lastreference to the instance is about to be destroyed. These hooks are NOTcalled every time "$ctx->release" is called.

GLOBAL

This is how you add a global release callback. Global callbacks happen for everycontext for any hub or stack.

    Test2::API::test2_add_callback_context_release(sub {        my $ctx = shift;        ...    });

PER HUB

This is how you add a release callback for all contexts created for a givenhub. These callbacks will not run for other hubs.

    $hub->add_context_release(sub {        my $ctx = shift;        ...    });

PER CONTEXT

This is how you add release callbacks directly to a context. The callback willALWAYS be added to the context that gets returned, it does not matter if anew one is generated, or if an existing one is returned.

    my $ctx = context(on_release => sub {        my $ctx = shift;        ...    });

THIRD PARTY META-DATA

This object consumes Test2::Util::ExternalMeta which provides a consistentway for you to attach meta-data to instances of this class. This is useful fortools, plugins, and other extensions.