view release on metacpan or  search on metacpan

t/Proxy.t  view on Meta::CPAN

            ok($req->method eq 'GET', 'retrieving a har via GET');
            $req->new_response(200, ['Content-Type' => 'application/json'], fake_har_fixture());
        };

        my $proxy = Browsermob::Proxy->new(
            server_port => $server_port,
            port => $port,
            mock => $har_server
        );

        my $har = $proxy->har;
        isa_ok($har, 'HASH', 'the retrieved har is a hash');
        ok(exists $har->{log}, 'with a log entry');
        ok(exists $har->{log}->{entries}->[0], 'that has an entries arrayref');
    }
}

CAPABILITIES: {
  MANUAL_HAR: {
        my $proxy = Browsermob::Proxy->new(
            server_port => $server_port,
            port => $port,
            mock => generate_mock_server()
        );

        my $caps = $proxy->selenium_proxy(1);
        isa_ok($caps, 'HASH', 'caps is a hashref');
        ok($caps->{proxyType} eq 'manual', 'and has a proxyType');
        ok($caps->{httpProxy} =~ /$port/i, 'and a httpUrl proxyType to the correct port');

        my $addr = $proxy->server_addr;
        cmp_ok($caps->{httpProxy}, '=~', qr/$addr/i, 'and the correct server addr');

        ok($caps->{sslProxy} =~ /$port/i, 'and a httpUrl proxyType to the correct port in SSL');

        $addr = $proxy->server_addr;
        cmp_ok($caps->{sslProxy}, '=~', qr/$addr/i, 'and the correct server addr in SSL');
    }

  AUTOMATIC_NEW_HAR: {
        my $new_har_was_called = 0;
        my $mock_server = generate_mock_server();
        $mock_server->{'/proxy/' . $port . '/har'} = sub {
            my $req = shift;
            $new_har_was_called++;
            $req->new_response(200, ['Content-Type' => 'application/json'], "");
        };

        my $caps = Browsermob::Proxy->new(
            server_port => $server_port,
            port => $port,
            mock => $mock_server
        )->selenium_proxy;

        ok($new_har_was_called, 'invoking selenium_proxy creates a new har by default');
    }

  FIREFOX_PROXY: {
        my $mock_server = generate_mock_server();

        my $firefox_prefs = Browsermob::Proxy->new(
            server_port => $server_port,
            port => $port,
            mock => $mock_server
        )->firefox_proxy('do not initiate');

        my @required_keys = qw/
                                  network.proxy.type
                                  network.proxy.http
                                  network.proxy.http_port
                                  network.proxy.ssl
                                  network.proxy.ssl_port
                              /;

        foreach (@required_keys) {
            ok(exists $firefox_prefs->{$_}, $_ . ' exists in firefox prefs.');
        }
    }
}

BASIC_AUTH: {
  UNIT: {
        my $mock_server = generate_mock_server();

        $mock_server->{'/proxy/' . $port . '/auth/basic/.google.com'} = sub {
            my $req = shift;
            my $body = from_json($req->body);
            ok($body->{username} eq 'bmp', 'user is included in payload');
            ok($body->{password} eq 'pass', 'pass is included in payload');
            return $req->new_response(200, ['Content-Type' => 'application/json'], "");
        };

        my $proxy = Browsermob::Proxy->new(
            server_port => $server_port,
            port => $port,
            mock => $mock_server
        );

        try {
            $proxy->add_basic_auth({
                username => 'missing keys'
            });
        }
        catch {
            ok($_ =~ /required parameter/, 'basic auth checks for required parameters');
        };

        $proxy->add_basic_auth({
            domain => '.google.com',
            username => 'bmp',
            password => 'pass'
        });
    }

  INTEGRATION: {
      SKIP: {
            skip 'Bug in LittleProxy does not set auth', 1;
            use Net::Ping;
            my $p = Net::Ping->new('tcp', 1);
            skip 'cannot reach webdav.org', 1 unless $p->ping('test.webdav.org');

            my $proxy;
            try {
                $proxy = Browsermob::Proxy->new;
            }
            catch {
                print $_ . "\n";
            };
            skip 'no server running', 1 unless defined $proxy;

            $proxy->add_basic_auth({
                domain => '.webdav.org',
                username => 'user1',
                password => 'user1'
            });