Creating fixtures¶

You can create fixtures with normal Moo syntax. You can even make them lazy if you want:

    has fixture => (
        is => 'lazy'
    );
    sub _build_fixture { ... }

This becomes really useful with Test::Roo::Role. A role could define the attribute and require the builder method to be provided by the main test class.

Composing test roles¶

You can use roles to define units of test behavior and then compose them into your test class using the "with" function. Test roles may define attributes, declare tests, require certain methods and anything else you can regularly do with roles.

    use Test::Roo;
    with 'MyTestRole1', 'MyTestRole2';

See Test::Roo::Role and the Test::Roo::Cookbook for details and examples.

Setup and teardown¶

You can add method modifiers around the "setup" and "teardown" methods and these will be run before tests begin and after tests finish (respectively).

    before  setup     => sub { ... };
    after   teardown  => sub { ... };

You can also add method modifiers around "each_test", which will be run before and after every individual test. You could use these to prepare or reset a fixture.

    has fixture => ( is => 'lazy, clearer => 1, predicate => 1 );
    after  each_test => sub { shift->clear_fixture };

Roles may also modify "setup", "teardown", and "each_test", so the order that modifiers will be called will depend on when roles are composed. Be careful with "each_test", though, because the global effect may make composition more fragile.

You can call test functions in modifiers. For example, you could confirm that something has been set up or cleaned up.

    before each_test => sub { ok( ! shift->has_fixture ) };

Running tests¶

The simplest way to use Test::Roo with a single .t file is to let the "main" package be the test class and call "run_me" in it:

    # t/test.t
    use Test::Roo; # loads Moo and Test::More
    has class => (
        is      => 'ro',
        default => sub { "Digest::MD5" },
    );
    test 'load class' => sub {
        my $self = shift;
        require_ok( $self->class );
    }
    run_me;
    done_testing;

Calling "run_me(@args)" is equivalent to calling "__PACKAGE__->run_tests(@args)" and runs tests for the current package.

You may specify an optional description or hash reference of constructor arguments to customize the test object:

    run_me( "load MD5" );
    run_me( { class => "Digest::MD5" } );
    run_me( "load MD5", { class => "Digest::MD5" } );

See Test::Roo::Class for more about the "run_tests" method.

Alternatively, you can create a separate package (in the test file or in a separate .pm file) and run tests explicitly on that class.

    # t/test.t
    package MyTest;
    use Test::Roo;
    use lib 't/lib';
    has class => (
        is       => 'ro',
        required => 1,
    );
    with 'MyTestRole';
    package main;
    use strictures;
    use Test::More;
    for my $c ( qw/Digest::MD5 Digest::SHA/ ) {
        MyTest->run_tests("Testing $c", { class => $c } );
    }
    done_testing;

test¶

    test $label => sub { ... };

The "test" function adds a subtest. The code reference will be called with the test object as its only argument.

Tests are run in the order declared, so the order of tests from roles will depend on when they are composed relative to other test declarations.

top_test¶

    top_test $label => sub { ... };

The "top_test" function adds a "top level" test. Works exactly like "test" except it will not start a subtest. This is especially useful in very simple testing situations where the extra subtest level is just noise.

So for example the following test

    # t/test.t
    use Test::Roo;
    has class => (
        is       => 'ro',
        required => 1,
    );
    top_test basic => sub {
        my $self = shift;
        require_ok($self->class);
        isa_ok($self->class->new, $self->class);
    };
    for my $c ( qw/Digest::MD5 Digest::SHA/ ) {
        run_me("Testing $c", { class => $c } );
    }
    done_testing;

produces the following TAP

    t/test.t ..
        ok 1 - require Digest::MD5;
        ok 2 - The object isa Digest::MD5
        1..2
    ok 1 - Testing Digest::MD5
        ok 1 - require Digest::SHA1;
        ok 2 - The object isa Digest::SHA1
        1..2
    ok 2 - Testing Digest::SHA1
    1..2
    ok
    All tests successful.
    Files=1, Tests=2,  0 wallclock secs ( 0.02 usr  0.01 sys +  0.06 cusr  0.00 csys =  0.09 CPU)
    Result: PASS

run_me¶

    run_me;
    run_me( $description );
    run_me( $init_args   );
    run_me( $description, $init_args );

The "run_me" function calls the "run_tests" method on the current package and passes all arguments to that method. It takes a description and/or a hash reference of constructor arguments.

Bugs / Feature Requests¶

Please report any bugs or feature requests through the issue tracker at <https://github.com/dagolden/Test-Roo/issues>. You will be notified automatically of any progress on your issue.

Source Code¶

This is open source software. The code repository is available for public review and contribution under the terms of the license.

<https://github.com/dagolden/Test-Roo>

  git clone https://github.com/dagolden/Test-Roo.git