view release on metacpan or  search on metacpan

t/21_port_forward.t  view on Meta::CPAN

#!/usr/bin/env perl
use strict;
use warnings;
use Test::More;
use Test::Exception;
use FindBin;
use lib "$FindBin::Bin/lib";
use lib "$FindBin::Bin/../lib";

use Kubernetes::REST;
use Kubernetes::REST::Server;
use Kubernetes::REST::AuthToken;
use Kubernetes::REST::HTTPResponse;

{
    package Test::PF::BasicIO;
    use Moo;
    with 'Kubernetes::REST::Role::IO';

    sub call {
        return Kubernetes::REST::HTTPResponse->new(status => 200, content => '{}');
    }

    sub call_streaming {
        return Kubernetes::REST::HTTPResponse->new(status => 200, content => '');
    }
}

{
    package Test::PF::DuplexIO;
    use Moo;
    with 'Kubernetes::REST::Role::IO';

    has last_req  => (is => 'rw');
    has last_opts => (is => 'rw');

    sub call {
        return Kubernetes::REST::HTTPResponse->new(status => 200, content => '{}');
    }

    sub call_streaming {
        return Kubernetes::REST::HTTPResponse->new(status => 200, content => '');
    }

    sub call_duplex {
        my ($self, $req, %opts) = @_;
        $self->last_req($req);
        $self->last_opts(\%opts);
        return { ok => 1, type => 'duplex-session' };
    }
}

sub make_api {
    my ($io) = @_;
    return Kubernetes::REST->new(
        server      => Kubernetes::REST::Server->new(endpoint => 'https://mock.local'),
        credentials => Kubernetes::REST::AuthToken->new(token => 'MockToken'),
        resource_map_from_cluster => 0,
        io          => $io,
    );
}

subtest 'supports_duplex probe' => sub {
    my $basic = Test::PF::BasicIO->new;
    my $duplex = Test::PF::DuplexIO->new;
    ok(!$basic->supports_duplex, 'basic backend reports no duplex support');
    ok($duplex->supports_duplex, 'duplex backend reports duplex support');
};

subtest 'port_forward requires name and ports' => sub {
    my $api = make_api(Test::PF::DuplexIO->new);

    throws_ok {
        $api->port_forward('Pod', namespace => 'default', ports => [8080]);
    } qr/name required for port_forward/, 'name is required';

    throws_ok {
        $api->port_forward('Pod', 'nginx', namespace => 'default');
    } qr/ports required for port_forward/, 'ports are required';
};

subtest 'port_forward validates ports' => sub {
    my $api = make_api(Test::PF::DuplexIO->new);

    throws_ok {
        $api->port_forward('Pod', 'nginx', namespace => 'default', ports => []);
    } qr/ports required for port_forward/, 'empty port list rejected';

    throws_ok {
        $api->port_forward('Pod', 'nginx', namespace => 'default', ports => ['abc']);
    } qr/invalid port/, 'non-numeric port rejected';

    throws_ok {
        $api->port_forward('Pod', 'nginx', namespace => 'default', ports => [70000]);
    } qr/invalid port/, 'out-of-range port rejected';
};

subtest 'port_forward fails when backend has no duplex transport' => sub {
    my $api = make_api(Test::PF::BasicIO->new);

    throws_ok {
        $api->port_forward('Pod', 'nginx', namespace => 'default', ports => [8080]);
    } qr/missing call_duplex/, 'clear error for unsupported backend';
};

subtest 'port_forward builds request and forwards callbacks' => sub {
    my $io = Test::PF::DuplexIO->new;
    my $api = make_api($io);

    my $open_called = 0;
    my $frame_cb = sub { };
    my $close_cb = sub { };
    my $error_cb = sub { };

    my $session = $api->port_forward('Pod', 'nginx',
        namespace   => 'default',