Image

head

nested

code

item

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

use v6;
use Test::Util::ServerPort;
use HTTP::Server::Async;
use Test::HTTP::Server::Event;
use YAMLish;

unit class Test::HTTP::Server:ver<0.5.2>:auth<zef:Scimon>;

has Int $.port;
has Str $.dir;
has HTTP::Server::Async $!server;
has Supplier $!server-event-writer;
has Supply $!server-event-reader;
has Channel $!event-queue;
has @!events;
has %!type-map;
has %!path-index;
has %!path-rules;

submethod BUILD( :$dir ) {
    $!port = get-unused-port();
    $!dir := $dir;
    $!server-event-writer = Supplier.new();
    $!server-event-reader = $!server-event-writer.Supply;
    $!server-event-reader.tap( -> $d { self!store-event( $d ) } );
    $!event-queue = Channel.new();
    %!type-map = (
        'html' => 'text/html',
        'png'  => 'image/png',
        'jpg'  => 'image/jpeg',
        'jpeg' => 'image/jpeg',
        'gif'  => 'image/gif',
        'js'   => 'application/javascript',
        'json' => 'application/json',
        'css'  => 'text/css',
        'xml'  => 'application/xml',
    );
    %!path-index = ();
    %!path-rules = ();
    
    $!server = HTTP::Server::Async.new( :port($!port) );
    
    $!server.handler( -> $req, $res { self!handle-request( $req, $res ) } );
    $!server.listen();

    if ( "{$!dir}config.yml".IO.f ) {
        my %data = load-yaml( "{$!dir}config.yml".IO.slurp );
        if %data<mime>:exists {
            %!type-map = ( |%!type-map, |%data<mime> );
        }
        if %data<paths>:exists {
            %!path-rules = (|%data<paths>);
        }
    }
    
}

method mime-types() {
    return %!type-map;
}

method !get-type ( $path ) {
    %!type-map{$path.IO.extension} // 'text/plain';
}

method !process-return-rule( $uri, $request, $response ) {
    %!path-index{$uri} //= 0;
    my $rule =  %!path-rules{$uri}<returns>[%!path-index{$uri}];

    if ( $rule ~~ "loop" ) {
        %!path-index{$uri} = 0;
        $rule =  %!path-rules{$uri}<returns>[%!path-index{$uri}];
    }

    if ( $rule ~~ m/^\d ** 3$/ ) {
        self!register-event( :code($rule), :path($uri), :method($request.method) );
        $response.status = $rule;
        $response.close();
    } elsif ( $rule ~~ "file" ) {
        self!register-event( :code(200), :path($uri), :method($request.method) );
        $response.headers<Content-Type> = self!get-type( "{$.dir}{$uri}" );
        $response.close("{$.dir}{$uri}".IO.slurp(:bin));
    }

    %!path-index{$uri}++ unless %!path-index{$uri} == %!path-rules{$uri}<returns>.elems-1;
}

method !handle-request( $request, $response ) {
    my $uri = $request.uri;
    if ( %!path-rules{$uri}:exists ) {
        self!process-return-rule( $uri, $request, $response );
    }
    elsif ( "{$.dir}{$uri}".IO.f ) {
        self!register-event( :code(200), :path($uri), :method($request.method) );
        $response.headers<Content-Type> = self!get-type( "{$.dir}{$uri}" );
        $response.close("{$.dir}{$uri}".IO.slurp(:bin));
    } else {
        self!register-event( :code(404), :path($uri), :method($request.method) );
        $response.status = 404;
        $response.close();
    }
}

method !register-event( :$code, :$path, :$method ) {
    $!server-event-writer.emit( { :code($code), :path($path), :method($method) } );
}

method !store-event( %data ) {
    my $event = Test::HTTP::Server::Event.new( |%data );
    $!event-queue.send( $event );
}

method events() {
    $!event-queue.close;
    @!events.push($_) for $!event-queue.list;
    $!event-queue = Channel.new();    
    @!events.clone;
}

method clear-events() {
    my $elems = @!events.elems;
    @!events = [];
    %!path-index = ();
    return $elems;
}



Test::HTTP::Server - Simple to use wrapper around HTTP::Server::Async designed for tests


# Simple usage
# $path is a folder with a selection of test files including index.html
my $test-server = Test::HTTP::Server.new( :dir($path) );


# method-to-test expects a web host and will make a GET request to host/index.html
ok method-to-test( :host( "http://localhost:{$test-server.port}" ) ), "This is a test";
# Other tests on the results here.


my @events = $test-server.events;
is @events.elems, 1, "One request made";
is @events[0].path, '/index.html', "Expected path called";
is @events[0].method, 'GET', "Expected method used";
is @events[0].code, 200, "Expected response code";
$test-server.clear-events;


Test::HTTP::Server is a wrapper around HTTP::Server::Async designed to allow for simple Mock testing of web services.


The constructor accepts a 'dir' and an optional 'port' parameter.


The server will server up any files that exist in 'dir' on the given port (if not port is given then one will be assigned, the '.port' method can be accessed to find what port is being used).


All requests are logged in a basic even log allowing for testing. If you make multiple async requests to the server the ordering of the events list cannot be assured and tests should be written based on this.


If a file doesn't exist then the server will return a 404.


Currently the server returns all files as 'text/plain' except files with the following extensions :


You can include a file called C<config.yml> in the file which allows for additional control over the responses.
The following keys are available :


Hash representation of extension and mime type header allows adding additional less common mime types.


Hash where keys are paths to match (including leading C</>), values are hashes with the currently allowed keys :


A list of commands to specify the return result, currently valid values.


Each time a request is made to the given path the next response in the list will be given. If the end of the list is reached then this result will
be returned from then on.


Returns the list of event objects giving the events registered to the server. Note if async requests are being made the order of events cannot be assured.


Events objects have the following attributes :


Clear the event list allowing the server to be reused in further tests.
Calling this method will also reset all the indexes on 'returns' in the config files. Further requests will start from the first registered response.


Returns a hash of mime-types registered with the server including any added in C<config.yml> file. 


This is a very basic version of the server in order to allow other development to be worked on. Planned is to allow a config.yml file to exist in the top level directory. If the file exists it will allow you control different paths and their responses.


This is intended to allow the system to replicate errors to allow for error testing.


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


Server

NAME
Test::Grammar - Test pieces of a grammar


parses-ok Test-Grammar,"num", 3, "33 parses OK";


my $test-output = q:to/EOC/;
ok 1 - bailout parses OK
ok 2 - «bailout» extracts token
1..2
EOC


has-tokens Test-Grammar, "test", <nok num description>, $test-output,
    "Complete tests";


token-is Test-Grammar,"bailout", "explanation",
    "Bail out! FOOBAR",
    "FOOBAR",
    "«bailout» extracts token";


for <foo bar b3> {
    parses-nok Test-Grammar,"num", $_, "$_ not parsed";
}


DESCRIPTION
This module is intended as a white-box test for grammars


sub parses-ok( Grammar $grammar,
               $token-or-rule,
               Str $str,
               $message = "👍" )


Checks that the grammar rule, contained in a strings, parses the string,
returning something, without really worrying about what it actually returns.


sub parses-nok( Grammar $grammar,
               $token-or-rule,
               Str $str,
               $message = "👎 $str" )


Checks that it does not parse the handled string


sub has-tokens( Grammar $grammar,
                $token-or-rule,
                @tokens,
                Str $str,
                $message = "👍" ) is export {


After parsing a token/rule/regex in a grammar, the resulting match includes
those
sub-matches (also called, confusingly enough, tokens).


sub parses-to( Grammar $grammar,
                $token-or-rule,
                Str $str,
                $message = "👍" )


String is parsed to itself by the rule. (I might merge this to the first one
later, maybe)


sub token-is( Grammar $grammar,
              $token-or-rule,
              $token,
              Str $str,
              Str $token-str,
              $message = "👍" )


Checks if an internal subtoken extracts the value correctly



use Test;

unit module Test::Grammar;

sub parses-ok( Grammar $grammar,
               $token-or-rule,
               Str $str,
               $message = "👍" ) is export {

    ok $grammar.subparse($str, :rule($token-or-rule)), $message;

}

sub parses-nok( Grammar $grammar,
               $token-or-rule,
               Str $str,
               $message = "👎 $str" ) is export {

    nok $grammar.subparse($str, :rule($token-or-rule)), $message;

}

sub has-tokens( Grammar $grammar,
                $token-or-rule,
                @tokens,
                Str $str,
                $message = "👍" ) is export {

    my $parsed = $grammar.subparse($str, :rule($token-or-rule));
    cmp-ok [$parsed.keys], "⊇", @tokens, $message;
}

sub token-is( Grammar $grammar,
              $token-or-rule,
              $token,
              Str $str,
              Str $token-str,
              $message = "👍" ) is export {

    my $parsed = $grammar.subparse($str, :rule($token-or-rule));
    is $parsed{$token}, $token-str, $message;
}

sub parses-to( Grammar $grammar,
                $token-or-rule,
                Str $str,
                $message = "👍" ) is export {

    my $match = $grammar.subparse($str, :rule($token-or-rule));
    is ~$match, $str, $message;
}



Grammar

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::Grammar for Raku

Installing

Running

See also

License

Test::Grammar v0.0.1

Authors

License

Dependencies

Test Dependencies

Provides

Documentation