The Perl Toolchain Summit needs more sponsors. If your company depends on Perl, please support this very important event.
NAME

    Test::Moose::More - More tools for testing Moose packages

VERSION

    This document describes version 0.031 of Test::Moose::More - released
    June 30, 2015 as part of Test-Moose-More.

SYNOPSIS

        use Test::Moose::More;
    
        is_class_ok 'Some::Class';
        is_role_ok  'Some::Role';
        has_method_ok 'Some::Class', 'foo';
    
        # ... etc

DESCRIPTION

    This package contains a number of additional tests that can be employed
    against Moose classes/roles. It is intended to replace Test::Moose in
    your tests, and re-exports any tests that it has and we do not, yet.

FUNCTIONS

 known_sugar

    Returns a list of all the known standard Moose sugar (has, extends,
    etc).

TEST_FUNCTIONS

 meta_ok $thing

    Tests $thing to see if it has a metaclass; $thing may be the class name
    or instance of the class you wish to check.

 does_ok $thing, < $role | \@roles >, [ $message ]

    Checks to see if $thing does the given roles. $thing may be the class
    name or instance of the class you wish to check.

    Note that the message will be taken verbatim unless it contains %s
    somewhere; this will be replaced with the name of the role being tested
    for.

 does_not_ok $thing, < $role | \@roles >, [ $message ]

    Checks to see if $thing does not do the given roles. $thing may be the
    class name or instance of the class you wish to check.

    Note that the message will be taken verbatim unless it contains %s
    somewhere; this will be replaced with the name of the role being tested
    for.

 has_attribute_ok $thing, $attribute_name, [ $message ]

    Checks $thing for an attribute named $attribute_name; $thing may be a
    class name, instance, or role name.

 has_method_ok $thing, @methods

    Queries $thing's metaclass to see if $thing has the methods named in
    @methods.

 role_wraps_around_method_ok $role, @methods

    Queries $role's metaclass to see if $role wraps the methods named in
    @methods with an around method modifier.

 role_wraps_before_method_ok $role, @methods

    Queries $role's metaclass to see if $role wraps the methods named in
    @methods with an before method modifier.

 role_wraps_after_method_ok $role, @methods

    Queries $role's metaclass to see if $role wraps the methods named in
    @methods with an after method modifier.

 requires_method_ok $thing, @methods

    Queries $thing's metaclass to see if $thing requires the methods named
    in @methods.

    Note that this really only makes sense if $thing is a role.

 is_immutable_ok $thing

    Passes if $thing is immutable.

 is_not_immutable_ok $thing

    Passes if $thing is not immutable; that is, is mutable.

 is_role_ok $thing

    Passes if $thing's metaclass is a Moose::Meta::Role.

 is_class_ok $thing

    Passes if $thing's metaclass is a Moose::Meta::Class.

 is_anon_ok $thing

    Passes if $thing is "anonymous".

 is_not_anon_ok $thing

    Passes if $thing is not "anonymous".

 check_sugar_removed_ok $thing

    Ensures that all the standard Moose sugar is no longer directly
    callable on a given package.

 check_sugar_ok $thing

    Checks and makes sure a class/etc can still do all the standard Moose
    sugar.

 validate_thing

    Runs a bunch of tests against the given $thing, as defined:

        validate_thing $thing => (
    
            attributes => [ ... ],
            methods    => [ ... ],
            isa        => [ ... ],
    
            # ensures sugar is/is-not present
            sugar      => 0,
    
            # ensures $thing does these roles
            does       => [ ... ],
    
            # ensures $thing does not do these roles
            does_not   => [ ... ],
        );

    $thing can be the name of a role or class, an object instance, or a
    metaclass.

    The attributes list specified here is in the form of a list of names,
    each optionally followed by a hashref of options to test the attribute
    for; this hashref takes the same arguments "validate_attribute" does.
    e.g.:

        validate_thing $thing => (
    
            attributes => [
                'foo',
                'bar',
                baz => { is => 'ro', ... },
                'bip',
            ],
        );

 validate_role

    The same as validate_thing(), but ensures $thing is a role, and allows
    for additional role-specific tests.

        validate_role $thing => (
    
            required_methods => [ ... ],
    
            # ...and all other options from validate_thing()
        );

 validate_class

    The same as validate_thing(), but ensures $thing is a class, and allows
    for additional class-specific tests.

        validate_class $thing => (
    
            isa  => [ ... ],
    
            attributes => [ ... ],
            methods    => [ ... ],
            isa        => [ ... ],
    
            # ensures sugar is/is-not present
            sugar      => 0,
    
            # ensures $thing does these roles
            does       => [ ... ],
    
            # ensures $thing does not do these roles
            does_not   => [ ... ],
    
            # ...and all other options from validate_thing()
        );

 validate_attribute

    validate_attribute() allows you to test how an attribute looks once
    built and attached to a class.

    Let's say you have an attribute defined like this:

        has foo => (
            traits  => [ 'TestRole' ],
            is      => 'ro',
            isa     => 'Int',
            builder => '_build_foo',
            lazy    => 1,
        );

    You can use validate_attribute() to ensure that it's built out in the
    way you expect:

        validate_attribute TestClass => foo => (
    
            # tests the attribute metaclass instance to ensure it does the roles
            -does => [ 'TestRole' ],
            # tests the attribute metaclass instance's inheritance
            -isa  => [ 'Moose::Meta::Attribute' ], # for demonstration's sake
    
            traits   => [ 'TestRole' ],
            isa      => 'Int',
            does     => 'Bar',
            handles  => { },
            reader   => 'foo',
            builder  => '_build_foo',
            default  => undef,
            init_arg => 'foo',
            lazy     => 1,
            required => undef,
        );

    Options passed to validate_attribute() prefixed with '-' test the
    attribute's metaclass instance rather than a setting on the attribute;
    that is, '-does' ensures that the metaclass does a particular role
    (e.g. MooseX::AttributeShortcuts), while 'does' tests the setting of
    the attribute to require the value do a given role.

    Not yet documented or tested exhaustively; please see
    t/validate_attribute.t for details at the moment. This test routine is
    likely to change in implementation and scope, with every effort to
    maintain backwards compatibility.

 attribute_options_ok

    Validates that an attribute is set up as expected; like
    validate_attribute(), but only concerns itself with attribute options.

    Not yet documented or tested exhaustively; please see
    t/validate_attribute.t for details at the moment. This test routine is
    likely to change in implementation and scope, with every effort to
    maintain backwards compatibility.

SEE ALSO

    Please see those modules/websites for more information related to this
    module.

      * Test::Moose

BUGS

    Please report any bugs or feature requests on the bugtracker website
    https://github.com/RsrchBoy/Test-Moose-More/issues

    When submitting a bug or request, please include a test-file or a patch
    to an existing test-file that illustrates the bug or desired feature.

AUTHOR

    Chris Weyl <cweyl@alumni.drew.edu>

 I'm a material boy in a material world

    Please note I do not expect to be gittip'ed or flattr'ed for this work,
    rather it is simply a very pleasant surprise. I largely create and
    release works like this because I need them or I find it enjoyable;
    however, don't let that stop you if you feel like it ;)

    Flattr
    <https://flattr.com/submit/auto?user_id=RsrchBoy&url=https%3A%2F%2Fgithub.com%2FRsrchBoy%2FTest-Moose-More&title=RsrchBoy's%20CPAN%20Test-Moose-More&tags=%22RsrchBoy's%20Test-Moose-More%20in%20the%20CPAN%22>,
    Gratipay <https://gratipay.com/RsrchBoy/>, or indulge my Amazon
    Wishlist <http://bit.ly/rsrchboys-wishlist>... If and *only* if you so
    desire.

CONTRIBUTORS

      * Chad Granum <chad.granum@dreamhost.com>

      * Karen Etheridge <ether@cpan.org>

COPYRIGHT AND LICENSE

    This software is Copyright (c) 2012 by Chris Weyl.

    This is free software, licensed under:

      The GNU Lesser General Public License, Version 2.1, February 1999