AnyEvent-Promises

 view release on metacpan or  search on metacpan

lib/AnyEvent/Promises/Deferred.pm  view on Meta::CPAN

    }
    return $d->promise;
}

# runs the promise synchronously
sub _promise_sync {
    my $this = shift;
    my $timeout = shift || 5;

    my $cv      = AE::cv;
    my $tm      = AE::timer $timeout, 0, sub { $cv->send("TIMEOUT\n") };
    $this->_promise_then( sub { $cv->send( undef, @_ ); }, sub { $cv->send(@_) } );
    my ( $error, @res ) = $cv->recv;

    die $error if $error;
    return wantarray? @res: $res[0];
}

# can be used with AnyEvent < 6 having no postpone 
my $postpone;
if (defined &AE::postpone){

lib/AnyEvent/Promises/Deferred.pm  view on Meta::CPAN

    my @POSTPONE;

    my $postpone_exec = sub {
        undef $POSTPONE_W;

        &{ shift @POSTPONE } while @POSTPONE;
    };

    $postpone = sub {
        push @POSTPONE, shift;
        $POSTPONE_W ||= AE::timer( 0, 0, $postpone_exec );
        ();
    };
};

sub _do_then {
    my ( $this, $d, $on_fulfill, $on_reject ) = @_;

    my $rejected = $this->{state} == 2;
    my ( $value, $reason ) = @$this{qw(value reason)};
    if ( my $f = $rejected ? $on_reject : $on_fulfill ) {

t/03-make_promise.t  view on Meta::CPAN

            $p1->then(
                sub {
                    ok( $p2->is_fulfilled,
                        'in next tick promise from code is fulfilled too' );
                }
            );
            ok( $p1->is_fulfilled,
                'promise created from value is fulfilled' );
            ok( $p2->is_pending,
                'promise from code is pending, code was not evaluated yet' );
            my $w; $w = AE::timer(0,0, sub {undef $w; $cv->send });
        }
    );
};

subtest make_promise_with_throw => sub {
    my @data;
    run_event_loop(
        sub {
            my $cv = shift;
            my $p = make_promise( sub {die "oops\n"} );

t/05-sync.t  view on Meta::CPAN

for my $d ( deferred() ) {
    $d->resolve(qw(a b c));
    is(
        scalar($d->promise->sync), 
        'a',
        "sync on fulfilled promise - scalar context"
    );
}

for my $d ( deferred() ) {
    my $tm = AE::timer 1, 0, sub { $d->resolve( 4, 3, 2 ) };
    is_deeply(
        [ $d->promise->sync ],
        [ 4, 3, 2 ],
        "sync on delayed fulfilled promise"
    );
}

for my $d ( deferred() ) {
    my $tm = AE::timer 1, 0, sub { $d->resolve( 4, 3, 2 ) };
    is_deeply(
        [ $d->promise->sync ],
        [ 4, 3, 2 ],
        "sync on delayed fulfilled promise"
    );
}

for my $d ( deferred() ) {
    my $reason = "Oops, something got terribly wrong\n";
    $d->reject($reason);

t/05-sync.t  view on Meta::CPAN

        $d->promise->sync; 
    } qr{^\Q$reason}, "sync on rejected promise throws the reason";
}

for my $timeout ( undef, 2 ) {
    my $d = deferred();

    my @trace;
    my @tm = map {
        my $delay = $_;
        AE::timer $delay, 0, sub { push @trace, $delay }
    } 1, 3, 6;

    throws_ok {
        $d->promise->sync( $timeout || () );
    }
    qr{TIMEOUT\n}, "sync on pending promise (TIMEOUT)";

    if ($timeout) {
        is_deeply( \@trace, [1], "timeout can be set" );
    }

t/Utils.pm  view on Meta::CPAN

our @EXPORT = qw(run_event_loop el_subtest);

sub run_event_loop(&@) {
    my ( $code, %args ) = @_;

    my $timeout = defined $args{timeout}? $args{timeout}: 10;
    my $cv = AE::cv;
    my $tmer;
    $tmer
        = AE::timer( $timeout, 0, sub { undef $tmer; $cv->send('TIMEOUT') } );
    $code->($cv);
    $cv->recv;

    return $tmer ? 1: fail("Event loop failed");
}

1;

# vim: expandtab:shiftwidth=4:tabstop=4:softtabstop=0:textwidth=78: