Image

head

code

root

para

L<Examples| file:../examples/index.podlite>


L<Download |file:../download/index.podlite>


React

=begin React :component<HeaderCol> :id<menu> 
=para L<Documentation|/doc/introduction>
=para L<Modules| /mods>
=para L<Examples| file:../examples/index.podlite>
=para L<Download |file:../download/index.podlite>
=para L<About|file:../about/index.podlite>
=para 🔍 K<⌘K>/K<ctrl-K>
=end React


HEADER

FOOTER

README

Test::Selector - Mark and selectively run only parts of test files


During development of a module, you may want to run only one or more
of the tests in its test files to see how your code is coming along;
you may not yet care whether the other tests pass or not or you just
don't want to have to wait for them to finish.


The traditional way to run tests separately is to have them in
different files, but this can lead to having many of them and it might
be hard to find which ones are relevant at any point during
development.


With this module, you will be able to wrap into labeled blocks parts
of your test files and use the supplied ｢tsel｣ program to select which
of these blocks to run. It also lets you specify where to find the
test files and in which ones to look for the blocks. You can also
specify where to find other modules that may be required, but not yet
installed.


Given the following (uninteresting) original code from a test file:


my $str = 'abc';
ok(
    $str.chars == $str.flip.chars,
    "A reversed string is the same length as the original.",
);


for the purpose of this module, you would wrap it like this with some
arbitrary label, here 's1':


t s1 => {
    my $str = 'abc';
    ok(
        $str.chars == $str.flip.chars,
        "A reversed string is the same length as the original.",
    );
};


｢t｣ is a subroutine exported by the module. It can be invoked in one
of the following example ways:


By default, ｢tsel｣ expects you to run it from the root directory of
your module in development; that is, it expects to find there a ./t
subdirectory with the test files, and a ./lib subdirectory to which it
will set RAKULIB before running the tests.


cd ⟨Module directory⟩
tsel s1
tsel -f=04 s\*
tsel -q ⋯
tsel -l s\*
tsel -ri=⋯/SomeModule/lib,/⋯/OtherModule/lib ⋯


cd ⟨Arbitrary directory⟩
tsel -t=⋯/MyModule/t -r=⋯/MyModule/lib,⋯/OtherModule/lib ⋯


Only blocks whose label matches the specified pattern will be
run. Some characters in the pattern are special; here is what
they match:


*    : any string, zero or more characters
?    : exactly one character
[…]  : characters from a set, for example ｢[abc]｣


Here are some examples, escaping the special characters to
prevent them from being expanded by the shell, and labels they
could match or not:


n\*      Yes: n, n1, nything     No: an
\[ab]\*c Yes: axc, a23c, bc      No: abcd, ebc
a1\?     Yes: a11, a1x           No: a1, a1bc


Only files whose extension is ｢.rakutest｣, ｢.t｣, or ｢.t6｣ and
whose name starts with the specified prefix characters will be
used.


Default: all files with the proper extension will be used.


-f=04   Yes: 04-foo.rakutest, 04.t6  No: 04-bar.raku


-t=⟨Use test files found in these comma separated directories⟩
-ti=⟨Use test files found in ./t and in these comma separated directories⟩


At most one of these options may be specified. If none is
specified, test files will be searched for in ./t, the idea being
that you will usually be running the program from the root of
the module in development.


-r=⟨Prepend to RAKULIB these comma separated directories⟩
-ri=⟨Prepend to RAKULIB ./lib and these comma separated directories⟩


At most one of these options may be specified. If none is
specified, ./lib will be prepended to RAKULIB, the idea being
that you will usually be running the program from the root of
the module in development.


This will only alphabetically list all matching block labels.


Run blocks more quietly, preventing ｢ok:｣ and ｢# Subtest:｣
lines from being displayed.


Used in a labeled block, returns the block's label. For example, when
run, the following block outputs «My label is a42␤»:


t a42 => {
    say "My label is ", label;
};


Prepend ｢__｣ or ｢_｣ (double or single underscore) to the block label:


__  : The block will be completely ignored.


_   : The block will not be run, but a 'skipped' message will be
      displayed.


t   s1 => { say "I'm block '{label}'." };
t __s2 => { say "I'm block '{label}'." };
t  _s3 => { say "I'm block '{label}'." };


# Testing ⟨the file⟩:
   # s1
I'm block 's1'.
   # _s3 : skipped
1..0



# --------------------------------------------------------------------
use IO::Glob;

my $block-def_sub;
my $block-lbl_sub;

class Test::Selector {

    my $glob = %*ENV<TEST_SELECTOR_BLOCKS_LABEL_PATTERN> // '*';
    my $action = %*ENV<TEST_SELECTOR_ACTION> // 'run';

    proto sub block-lbl (|) is export {*}
    $block-lbl_sub = &block-lbl;

    multi sub block-lbl { return %*ENV<TEST_SELECTOR_LABEL> }

    proto sub block-def (|) is export {*}
    $block-def_sub = &block-def;

        # Allows arguments like ｢$a => { ⋯ }｣.
    multi sub block-def (Pair $def) {
        _block-def($def.key, $def.value);
    }

        # Allows arguments like ｢a => { ⋯ }｣. The previous sub
        # signature would fail, since a Pair within an argument list
        # with an unquoted identifier on the left is interpreted as a
        # named argument, not as a Pair.
    multi sub block-def (*%def) {
        my (Str $label, Block $code) = %def.kv;
        _block-def($label, $code);
    }

    sub _block-def (Str $label, Block $code) {
        my $to_match = $label;
        my $silent = so $to_match ~~ s/^__//;
        my $skip = so $to_match ~~ s/^_//;
        %*ENV<TEST_SELECTOR_LABEL> = $label;
        if ($to_match ~~ glob($glob)) {
            say($label), return if $action eq 'list';
            return unless $action eq 'run' && ! $silent;
            say("   # $label : skipped"), return if $skip;
            say "   # $label";
            $code.();
        }
    }

}

sub EXPORT ($block-def_sub-name = 't', $block-lbl_sub-name = 'label') {
    Map.new:
        "&$block-def_sub-name" => $block-def_sub,
        "&$block-lbl_sub-name" => $block-lbl_sub,
    ;
}



Selector

output-is "script.p6", "hello: goodbye\n", "Two args ",
        args => ["--msg=goodbye", "hello"];


output-like "script.p6, /"hello → goodbye"/, "Prints environment ",
        env => { "hello" => "goodbye" };


variable-ok "script.p6", '$foo', "Variable exists and is set";
variable-is "script.p6", '$foo', <bar baz>, "Variable exists and has value";


This module is intended as a white-box test for scripts. Instead of running
them as black boxes, it incorporates them into the current program, allowing
better examination of its internal workings.


For the time being, it's just the output, but in the roadmap is the
examination of variable values and other dynamic stuff.



use Test;

unit module Test::Script;

subset Script of Str where .IO.e && / \.p6 || \.raku/;

#| Check the output of a $script, provided optional arguments and environment
sub output-is(Script $script,
              Str $desired-output,
              Str $msg,
              :@args,
              :%env ) is export {
    my $output= get-output( $script, :@args, :%env );
    is( $output, $desired-output, $msg);

}

#| Check the output via a regular expression
sub output-like(Script $script,
                Regex $desired-output,
                Str $msg,
                :@args,
                :%env  ) is export {
    my $output= get-output( $script, :@args, :%env );
    like( $output, $desired-output, $msg);

}

#| Checks that it fails in an expected way
sub error-like(Script $script,
                Regex $desired-output,
                Str $msg,
                :@args,
                :%env  ) is export {
    my $output= get-err( $script, :@args, :%env );
    like( $output, $desired-output, $msg);

}

sub get-output(Script $script,
              :@args,
              :%env ) {
    my $output;
    my $stdout = $*OUT;
    $*OUT = class {
        method print(*@args) {
            $output ~= @args.join;
        }
        method flush {}
    }
    try {
        @*ARGS = @args.map: ~*;
        for %env.keys -> $k {
            %*ENV{$k} = %env{$k};
        }
        CompUnit::Loader.load-source-file($script.IO);
    }
    $*OUT = $stdout;
    $output;

}

sub get-err(Script $script,
              :@args,
              :%env ) {
    my $output;
    my $stderr = $*ERR;
    $*ERR = class {
        method print(*@args) {
            $output ~= @args.join;
        }
        method flush {}
    }
    try {
        @*ARGS = @args.map: ~*;
        for %env.keys -> $k {
            %*ENV{$k} = %env{$k};
        }
        CompUnit::Loader.load-source-file($script.IO);
        CATCH {
            default {
                $output ~= .message
            }
        }
    }
    $*ERR = $stderr;
    $output;

}

#| Check that a variable exist and is defined
sub variable-ok(Script $script,
                Str $variable,
                Str $message,
               :@args,
               :%env ) is export {
    my %vars = get-vars( $script, :@args, :%env);
    ok(%vars{$variable}, $message);

}

#| Check that a variable has certain value
sub variable-is(Script $script,
                Str $variable,
                Mu \value,
                Str $message,
                :@args,
                :%env ) is export {
    my %vars = get-vars( $script, :@args, :%env);
    is(%vars{$variable}, value, $message);

}

sub get-vars(Script $script,
                :@args,
                :%env ) is export {
    @*ARGS = @args;
    for %env.keys -> $k {
        %*ENV{$k} = %env{$k};
    }
    my $handle = CompUnit::Loader.load-source-file($script.IO);
    return $handle.globalish-package;

}



You can't test the same script twice in the same file. As a workaround
(probably temporary), call it under different names such as C<./script.p6> or
C<../dir/script.p6>; alternatively, just use different tests for different
scripts.


This library is free software; you can redistribute it and/or modify it under
the Artistic 2.0 license


Script

The Raku Knowledge Base


=begin React :component<HeaderCol> :id<footer>  
=begin nested :!nested
=item1 B<Language>
    =item2 L<Get started|file:../getting-started/getting-started.podlite>
    =item2 L<Why Raku?|/doc/language/faq#Why-should-I-learn-Raku-What's-so-great-about-it>
    =item2 L<Try Raku|https://glot.io/new/raku>
    =item2 L<Raku cheat sheet|https://github.com/Raku/mu/blob/master/docs/Perl6/Cheatsheet/cheatsheet.txt>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<Raku on Exercism|https://exercism.org/tracks/raku>
    =item2 L<Wikipedia|https://en.wikipedia.org/wiki/Raku_(programming_language)>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=begin nested :!nested

=item1 B<L<Documentation|/doc>>
    =item2 L<Getting started, Migration guides from other languages, & Tutorials | file:../doc/introduction.podlite>
    =item2 L<Language References|file:../doc/reference.podlite>
    =item2 L<Type Reference| file:../doc/types.podlite>
    =item2 L<Miscellaneous| file:../doc/miscellaneous.podlite>
    =item2 L<FAQs (Frequently Asked Questions)|/doc/language/faq>
    =item2 L<Community|/doc/language/community>
    =item2 L<The list of all documents|file:../doc/index.podlite>

=item1 B<Resources>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>

=end nested
=begin nested :!nested

=item1 B<Resoures>
    =item2 L<Download | file:../download/index.podlite>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=item1 B<Learning>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Wikibook |https://en.wikibooks.org/wiki/Raku_Programming>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>
    =item2 L<Learn Raku in Y minutes|https://learnxinyminutes.com/docs/raku/>
    =item2 L<Golfing |https://github.com/AlexDaniel/raku-golf-cheatsheet>
=end nested
=begin nested :!nested

=item1 B<Explore>
    =item2 L<Raku Blog Aggregator|https://planet.raku.org/>
    =item2 L<Rakudo Weekly|https://rakudoweekly.blog/>
    =item2 L<The Weekly Challenge |https://perlweeklychallenge.org/>
    =item2 L<Raku Advent Calendar|https://raku-advent.blog/>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=end React


=begin React :component<CookieConsent> :id<CookieConsent> :buttonCaption("Got it!")
=para
This website uses cookies for analytics.
=end React


README

Test::Script

Installing

Running

See also

License

Test::Script v0.0.4

Authors

License

Dependencies

Test Dependencies

Provides

Documentation