This is the very rough cut of combining plackup (in the form of Plack::Runner) and Twiggy with WWW::Mechanize::Chrome. I intend to flesh this out a bit and package it into its own module, but for the time being it works well enough for me.

Currently, this sets up / patches a Dancer application, but I imagine that converting this to use/support Dancer2 shouldn't be too hard, since all you need to get is $app somewhere, and most likely, Dancer2::Test has just enough code to give you the appropriate $app somewhere.

#!perl -w
use strict;
use Twiggy::Server;
use Dancer::Test;
use File::Temp 'tempdir';
use WWW::Mechanize::Chrome;
use Log::Log4perl qw(:easy);
use Data::Dumper;
use Test::More tests => 15;

Log::Log4perl->easy_init($ERROR);  # Set priority of root logger to ER
+ROR
#Log::Log4perl->easy_init($TRACE);  # Set priority of root logger to E
+RROR

my $port = 5099;
my $server = Twiggy::Server->new(
    host => '127.0.0.1',
    port => $port,
);
$ENV{DANCER_APPHANDLER} = 'Dancer::Handler::PSGI';
my $handler = Dancer::Handler->get_handler();
Dancer::_load_app('App::mykeep');
my $app = $handler->psgi_app();
$server->register_service($app);

# Fudge the config as appropriate for our test
Dancer::config()->{mykeep}->{notes_dir} = tempdir(
    CLEANUP => 1,
);

my @cleanup_directories;
my $tempdir = tempdir( CLEANUP => 1 );

my $mech;
$mech = WWW::Mechanize::Chrome->new(
    launch_exe => 'C:\\Users\\Corion\\Projekte\\WWW-Mechanize-Chrome\\
+chrome-versions\\chrome-65.0.3301.0\\chrome.exe',
    data_directory => $tempdir,
    #headless => 1,
);

$mech->clear_js_errors();

my $console = $mech->add_listener('Runtime.consoleAPICalled', sub {
    diag join ", ",
        map { $_->{value} // $_->{description} }
        @{ $_[0]->{params}->{args} };
});

# run your tests here
# ...
[download]

Thanks, Corion. I'll take a close look at this.

I have one more very basic, big picture question. Why not just just fire up a server with a plackup command directly before running tests and just use that?

$PM = "Perl Monk's";
$MCF = "Most Clueless Friar Abbot Bishop Pontiff Deacon Curate Priest";
$nysus = $PM . ' ' . $MCF;
Click here if you love Perl Monks

In my case, I started out with launching my server with plackup, but then I wanted a custom configuration and a fresh database, and I wanted to override how some functions return errors etc., and all of that becomes more cumbersome, together with the uncertainity whether I'm really connecting to the fresh instance and not a left-over instance from a previously interrupted test run.

But for a very simple start, this is an old version of the end-to-end test run setup I had:

package helper;
use strict;
use File::Path;
use File::Temp 'tempdir';
use WWW::Mechanize::Chrome;

sub spawn_app {
    my( $port ) = @_;
    
    my $h = helper::Child->new;
    $h->spawn_child( 'plackup', '-a', 'bin/app.pl', '-p', $port );
    $h
}

my @cleanup_directories;
END {
    File::Path::rmtree($_, 0) for @cleanup_directories;
}

sub spawn_chrome {
    my $tempdir = tempdir();
    push @cleanup_directories, $tempdir;
    my $mech = WWW::Mechanize::Chrome->new(
        launch_exe => '...',
        data_directory => $tempdir,
        @_
    );
}

package helper::Child;
use strict;

sub new {
    my( $class, %options ) = @_;
    bless \%options => $class;
}

sub DESTROY {
    kill 'KILL', $_[0]->{pid};
    wait;
}

sub spawn_child_win32 { my ( $self, @cmd ) = @_;
    system(1, @cmd)
}

sub spawn_child_posix { my ( $self, @cmd ) = @_;
    require POSIX;
    POSIX->import("setsid");

    # daemonize
    defined(my $pid = fork())   || die "can't fork: $!";
    if( $pid ) {    # non-zero now means I am the parent
        $self->log('debug', "Spawned child as $pid");
        return $pid;
    };
    #chdir("/")                  || die "can't chdir to /: $!";

    # We are the child, close about everything, then exec
    (setsid() != -1)            || die "Can't start a new session: $!"
+;
    open(STDERR, ">&STDOUT")    || die "can't dup stdout: $!";
    open(STDIN,  "< /dev/null") || die "can't read /dev/null: $!";
    open(STDOUT, "> /dev/null") || die "can't write to /dev/null: $!";
    exec @cmd;
}

sub spawn_child { my ( $self, @cmd ) = @_;
    my ($pid);
    if( $^O =~ /mswin/i ) {
        $pid = $self->spawn_child_win32(@cmd)
    } else {
        $pid = $self->spawn_child_posix(@cmd)
    };
    $self->{pid} = $pid;

    return $pid
}

1;
[download]

Used as:

use lib './t';
use helper;

my $port = 5099;
my $server = helper::spawn_app( $port );
my $mech = helper::spawn_chrome(
);

...
[download]