2020-10-29 16:12:30 -07:00
/ * *
* Copyright ( c ) Microsoft Corporation .
*
* Licensed under the Apache License , Version 2.0 ( the "License" ) ;
* you may not use this file except in compliance with the License .
* You may obtain a copy of the License at
*
* http : //www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing , software
* distributed under the License is distributed on an "AS IS" BASIS ,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND , either express or implied .
* See the License for the specific language governing permissions and
* limitations under the License .
* /
2022-03-25 15:05:50 -08:00
import { browserTest as it , expect } from '../config/browserTest' ;
2021-04-05 18:48:46 -07:00
2023-07-25 16:47:04 -07:00
it . skip ( ( { mode } ) = > mode . startsWith ( 'service' ) ) ;
2021-10-26 12:45:53 -08:00
it . use ( {
launchOptions : async ( { launchOptions } , use ) = > {
await use ( {
. . . launchOptions ,
proxy : { server : 'per-context' }
} ) ;
}
} ) ;
2020-10-29 16:12:30 -07:00
2021-08-19 13:34:32 -07:00
it . beforeEach ( ( { s erver } ) = > {
server . setRoute ( '/target.html' , async ( req , res ) = > {
res . end ( '<html><title>Served by the proxy</title></html>' ) ;
} ) ;
} ) ;
2021-10-27 18:00:06 -08:00
it ( 'should throw for missing global proxy on Chromium Windows' , async ( { browserName , platform , browserType , server } ) = > {
2021-04-30 00:02:48 +02:00
it . skip ( browserName !== 'chromium' || platform !== 'win32' ) ;
2021-07-19 17:50:14 +02:00
let browser ;
try {
browser = await browserType . launch ( {
proxy : undefined ,
} ) ;
const error = await browser . newContext ( { proxy : { server : ` localhost: ${ server . PORT } ` } } ) . catch ( e = > e ) ;
expect ( error . toString ( ) ) . toContain ( 'Browser needs to be launched with the global proxy' ) ;
} finally {
await browser . close ( ) ;
}
2020-10-29 16:12:30 -07:00
} ) ;
2021-10-28 07:31:30 -08:00
it ( 'should work when passing the proxy only on the context level' , async ( { browserName , platform , browserType , server , proxyServer } ) = > {
2021-04-30 00:02:48 +02:00
// Currently an upstream bug in the network stack of Chromium which leads that
// the wrong proxy gets used in the BrowserContext.
it . fixme ( browserName === 'chromium' && platform === 'win32' ) ;
2021-08-19 13:34:32 -07:00
proxyServer . forwardTo ( server . PORT ) ;
2021-07-19 17:50:14 +02:00
let browser ;
try {
browser = await browserType . launch ( {
proxy : undefined ,
} ) ;
const context = await browser . newContext ( {
2021-08-19 13:34:32 -07:00
proxy : { server : ` localhost: ${ proxyServer . PORT } ` }
2021-07-19 17:50:14 +02:00
} ) ;
2021-04-30 00:02:48 +02:00
2021-07-19 17:50:14 +02:00
const page = await context . newPage ( ) ;
await page . goto ( 'http://non-existent.com/target.html' ) ;
2021-08-19 13:34:32 -07:00
expect ( proxyServer . requestUrls ) . toContain ( 'http://non-existent.com/target.html' ) ;
2021-07-19 17:50:14 +02:00
expect ( await page . title ( ) ) . toBe ( 'Served by the proxy' ) ;
} finally {
await browser . close ( ) ;
}
2021-04-30 00:02:48 +02:00
} ) ;
2021-05-09 17:47:20 -07:00
it ( 'should throw for bad server value' , async ( { contextFactory } ) = > {
const error = await contextFactory ( {
2020-10-29 16:12:30 -07:00
// @ts-expect-error server must be a string
proxy : { server : 123 }
} ) . catch ( e = > e ) ;
expect ( error . message ) . toContain ( 'proxy.server: expected string, got number' ) ;
} ) ;
2021-08-19 13:34:32 -07:00
it ( 'should use proxy' , async ( { contextFactory , server , proxyServer } ) = > {
proxyServer . forwardTo ( server . PORT ) ;
2021-05-09 17:47:20 -07:00
const context = await contextFactory ( {
2021-08-19 13:34:32 -07:00
proxy : { server : ` localhost: ${ proxyServer . PORT } ` }
2020-10-29 16:12:30 -07:00
} ) ;
2021-04-05 18:48:46 -07:00
const page = await context . newPage ( ) ;
2020-10-29 16:12:30 -07:00
await page . goto ( 'http://non-existent.com/target.html' ) ;
2021-08-19 13:34:32 -07:00
expect ( proxyServer . requestUrls ) . toContain ( 'http://non-existent.com/target.html' ) ;
2020-10-29 16:12:30 -07:00
expect ( await page . title ( ) ) . toBe ( 'Served by the proxy' ) ;
2021-04-05 18:48:46 -07:00
await context . close ( ) ;
2020-10-29 16:12:30 -07:00
} ) ;
2022-11-23 09:22:49 -08:00
it ( 'should set cookie for top-level domain' , async ( { contextFactory , server , proxyServer , browserName , isLinux } ) = > {
it . fixme ( browserName === 'webkit' && isLinux ) ;
2023-01-27 21:52:34 -08:00
2023-10-17 13:41:23 -07:00
proxyServer . forwardTo ( server . PORT , { allowConnectRequests : true } ) ;
2022-11-23 09:22:49 -08:00
const context = await contextFactory ( {
proxy : { server : ` localhost: ${ proxyServer . PORT } ` }
} ) ;
server . setRoute ( '/empty.html' , ( req , res ) = > {
res . setHeader ( 'Set-Cookie' , ` name=val; Domain=codes; Path=/; ` ) ;
res . end ( ) ;
} ) ;
await context . request . get ( 'http://codes/empty.html' ) ;
const [ cookie ] = await context . cookies ( ) ;
expect ( cookie ) . toBeTruthy ( ) ;
expect ( cookie . name ) . toBe ( 'name' ) ;
expect ( cookie . value ) . toBe ( 'val' ) ;
await context . close ( ) ;
} ) ;
2021-12-10 14:01:56 -08:00
it . describe ( 'should proxy local network requests' , ( ) = > {
for ( const additionalBypass of [ false , true ] ) {
it . describe ( additionalBypass ? 'with other bypasses' : 'by default' , ( ) = > {
for ( const params of [
{
target : 'localhost' ,
description : 'localhost' ,
} ,
{
target : '127.0.0.1' ,
description : 'loopback address' ,
} ,
{
target : '169.254.3.4' ,
description : 'link-local'
}
] ) {
it ( ` ${ params . description } ` , async ( { platform , browserName , contextFactory , server , proxyServer } ) = > {
2024-02-23 14:27:30 -08:00
it . skip ( browserName === 'webkit' && platform === 'darwin' && [ 'localhost' , '127.0.0.1' ] . includes ( params . target ) && additionalBypass , 'Mac webkit does not proxy localhost when bypass rules are set' ) ;
2021-12-10 14:01:56 -08:00
const path = ` /target- ${ additionalBypass } - ${ params . target } .html ` ;
server . setRoute ( path , async ( req , res ) = > {
res . end ( '<html><title>Served by the proxy</title></html>' ) ;
} ) ;
2024-02-23 14:27:30 -08:00
const url = ` http:// ${ params . target } :55555 ${ path } ` ;
2021-12-10 14:01:56 -08:00
proxyServer . forwardTo ( server . PORT ) ;
const context = await contextFactory ( {
proxy : { server : ` localhost: ${ proxyServer . PORT } ` , bypass : additionalBypass ? '1.non.existent.domain.for.the.test' : undefined }
} ) ;
const page = await context . newPage ( ) ;
await page . goto ( url ) ;
expect ( proxyServer . requestUrls ) . toContain ( url ) ;
expect ( await page . title ( ) ) . toBe ( 'Served by the proxy' ) ;
await page . goto ( 'http://1.non.existent.domain.for.the.test/foo.html' ) . catch ( ( ) = > { } ) ;
if ( additionalBypass )
expect ( proxyServer . requestUrls ) . not . toContain ( 'http://1.non.existent.domain.for.the.test/foo.html' ) ;
else
expect ( proxyServer . requestUrls ) . toContain ( 'http://1.non.existent.domain.for.the.test/foo.html' ) ;
await context . close ( ) ;
} ) ;
}
} ) ;
}
} ) ;
2021-10-13 12:10:09 -07:00
it ( 'should use ipv6 proxy' , async ( { contextFactory , server , proxyServer , browserName } ) = > {
it . fail ( browserName === 'firefox' , 'page.goto: NS_ERROR_UNKNOWN_HOST' ) ;
2021-10-20 02:03:46 -07:00
it . fail ( ! ! process . env . INSIDE_DOCKER , 'docker does not support IPv6 by default' ) ;
2021-10-13 12:10:09 -07:00
proxyServer . forwardTo ( server . PORT ) ;
const context = await contextFactory ( {
proxy : { server : ` [0:0:0:0:0:0:0:1]: ${ proxyServer . PORT } ` }
} ) ;
const page = await context . newPage ( ) ;
await page . goto ( 'http://non-existent.com/target.html' ) ;
expect ( proxyServer . requestUrls ) . toContain ( 'http://non-existent.com/target.html' ) ;
expect ( await page . title ( ) ) . toBe ( 'Served by the proxy' ) ;
await context . close ( ) ;
} ) ;
2021-08-19 13:34:32 -07:00
it ( 'should use proxy twice' , async ( { contextFactory , server , proxyServer } ) = > {
proxyServer . forwardTo ( server . PORT ) ;
2021-05-09 17:47:20 -07:00
const context = await contextFactory ( {
2021-08-19 13:34:32 -07:00
proxy : { server : ` localhost: ${ proxyServer . PORT } ` }
2020-10-29 16:12:30 -07:00
} ) ;
2021-04-05 18:48:46 -07:00
const page = await context . newPage ( ) ;
2020-10-29 16:12:30 -07:00
await page . goto ( 'http://non-existent.com/target.html' ) ;
2021-08-19 13:34:32 -07:00
expect ( proxyServer . requestUrls ) . toContain ( 'http://non-existent.com/target.html' ) ;
2020-10-29 16:12:30 -07:00
await page . goto ( 'http://non-existent-2.com/target.html' ) ;
2021-08-19 13:34:32 -07:00
expect ( proxyServer . requestUrls ) . toContain ( 'http://non-existent-2.com/target.html' ) ;
2020-10-29 16:12:30 -07:00
expect ( await page . title ( ) ) . toBe ( 'Served by the proxy' ) ;
2021-04-05 18:48:46 -07:00
await context . close ( ) ;
2020-10-29 16:12:30 -07:00
} ) ;
2021-09-27 18:58:08 +02:00
it ( 'should use proxy for second page' , async ( { contextFactory , server , proxyServer } ) = > {
2021-08-19 13:34:32 -07:00
proxyServer . forwardTo ( server . PORT ) ;
2021-05-09 17:47:20 -07:00
const context = await contextFactory ( {
2021-08-19 13:34:32 -07:00
proxy : { server : ` localhost: ${ proxyServer . PORT } ` }
2020-10-29 16:12:30 -07:00
} ) ;
2021-04-05 18:48:46 -07:00
const page = await context . newPage ( ) ;
2020-10-29 16:12:30 -07:00
await page . goto ( 'http://non-existent.com/target.html' ) ;
2021-08-19 13:34:32 -07:00
expect ( proxyServer . requestUrls ) . toContain ( 'http://non-existent.com/target.html' ) ;
2020-10-29 16:12:30 -07:00
expect ( await page . title ( ) ) . toBe ( 'Served by the proxy' ) ;
2021-04-05 18:48:46 -07:00
const page2 = await context . newPage ( ) ;
2021-08-19 13:34:32 -07:00
proxyServer . requestUrls = [ ] ;
2020-10-29 16:12:30 -07:00
await page2 . goto ( 'http://non-existent.com/target.html' ) ;
2021-08-19 13:34:32 -07:00
expect ( proxyServer . requestUrls ) . toContain ( 'http://non-existent.com/target.html' ) ;
2020-10-29 16:12:30 -07:00
expect ( await page2 . title ( ) ) . toBe ( 'Served by the proxy' ) ;
2021-04-05 18:48:46 -07:00
await context . close ( ) ;
2020-10-29 16:12:30 -07:00
} ) ;
2023-02-24 06:34:37 -08:00
it ( 'should use proxy for https urls' , async ( { contextFactory , httpsServer , proxyServer } ) = > {
2021-08-19 07:36:03 -07:00
httpsServer . setRoute ( '/target.html' , async ( req , res ) = > {
2021-08-19 13:34:32 -07:00
res . end ( '<html><title>Served by https server via proxy</title></html>' ) ;
2021-08-19 07:36:03 -07:00
} ) ;
2023-10-17 13:41:23 -07:00
proxyServer . forwardTo ( httpsServer . PORT , { allowConnectRequests : true } ) ;
2021-08-19 07:36:03 -07:00
const context = await contextFactory ( {
ignoreHTTPSErrors : true ,
proxy : { server : ` localhost: ${ proxyServer . PORT } ` }
} ) ;
const page = await context . newPage ( ) ;
await page . goto ( 'https://non-existent.com/target.html' ) ;
2021-08-19 13:34:32 -07:00
expect ( proxyServer . connectHosts ) . toContain ( 'non-existent.com:443' ) ;
expect ( await page . title ( ) ) . toBe ( 'Served by https server via proxy' ) ;
2021-08-19 07:36:03 -07:00
await context . close ( ) ;
} ) ;
2021-09-27 18:58:08 +02:00
it ( 'should work with IP:PORT notion' , async ( { contextFactory , server , proxyServer } ) = > {
2021-08-19 13:34:32 -07:00
proxyServer . forwardTo ( server . PORT ) ;
2021-05-09 17:47:20 -07:00
const context = await contextFactory ( {
2021-08-19 13:34:32 -07:00
proxy : { server : ` 127.0.0.1: ${ proxyServer . PORT } ` }
2020-10-29 16:12:30 -07:00
} ) ;
2021-04-05 18:48:46 -07:00
const page = await context . newPage ( ) ;
2020-10-29 16:12:30 -07:00
await page . goto ( 'http://non-existent.com/target.html' ) ;
2021-08-19 13:34:32 -07:00
expect ( proxyServer . requestUrls ) . toContain ( 'http://non-existent.com/target.html' ) ;
2020-10-29 16:12:30 -07:00
expect ( await page . title ( ) ) . toBe ( 'Served by the proxy' ) ;
2021-04-05 18:48:46 -07:00
await context . close ( ) ;
2020-10-29 16:12:30 -07:00
} ) ;
2021-09-27 18:58:08 +02:00
it ( 'should throw for socks5 authentication' , async ( { contextFactory } ) = > {
2021-05-09 17:47:20 -07:00
const error = await contextFactory ( {
2021-02-08 12:07:45 -08:00
proxy : { server : ` socks5://localhost:1234 ` , username : 'user' , password : 'secret' }
} ) . catch ( e = > e ) ;
expect ( error . message ) . toContain ( 'Browser does not support socks5 proxy authentication' ) ;
} ) ;
2021-09-27 18:58:08 +02:00
it ( 'should throw for socks4 authentication' , async ( { contextFactory } ) = > {
2021-05-09 17:47:20 -07:00
const error = await contextFactory ( {
2021-02-08 12:07:45 -08:00
proxy : { server : ` socks4://localhost:1234 ` , username : 'user' , password : 'secret' }
} ) . catch ( e = > e ) ;
expect ( error . message ) . toContain ( 'Socks4 proxy protocol does not support authentication' ) ;
} ) ;
2021-09-27 18:58:08 +02:00
it ( 'should authenticate' , async ( { contextFactory , server , proxyServer } ) = > {
2021-08-19 13:34:32 -07:00
proxyServer . forwardTo ( server . PORT ) ;
let auth ;
proxyServer . setAuthHandler ( req = > {
auth = req . headers [ 'proxy-authorization' ] ;
return ! ! auth ;
2020-10-29 16:12:30 -07:00
} ) ;
2021-05-09 17:47:20 -07:00
const context = await contextFactory ( {
2021-08-19 13:34:32 -07:00
proxy : { server : ` localhost: ${ proxyServer . PORT } ` , username : 'user' , password : 'secret' }
2020-10-29 16:12:30 -07:00
} ) ;
2021-04-05 18:48:46 -07:00
const page = await context . newPage ( ) ;
2020-10-29 16:12:30 -07:00
await page . goto ( 'http://non-existent.com/target.html' ) ;
2021-08-19 13:34:32 -07:00
expect ( proxyServer . requestUrls ) . toContain ( 'http://non-existent.com/target.html' ) ;
expect ( auth ) . toBe ( 'Basic ' + Buffer . from ( 'user:secret' ) . toString ( 'base64' ) ) ;
expect ( await page . title ( ) ) . toBe ( 'Served by the proxy' ) ;
2021-04-05 18:48:46 -07:00
await context . close ( ) ;
2020-10-29 16:12:30 -07:00
} ) ;
2021-09-27 18:58:08 +02:00
it ( 'should authenticate with empty password' , async ( { contextFactory , server , proxyServer } ) = > {
2021-08-19 13:34:32 -07:00
proxyServer . forwardTo ( server . PORT ) ;
let auth ;
proxyServer . setAuthHandler ( req = > {
auth = req . headers [ 'proxy-authorization' ] ;
return ! ! auth ;
2020-12-21 11:47:13 -08:00
} ) ;
2021-05-09 17:47:20 -07:00
const context = await contextFactory ( {
2021-08-19 13:34:32 -07:00
proxy : { server : ` localhost: ${ proxyServer . PORT } ` , username : 'user' , password : '' }
2020-12-21 11:47:13 -08:00
} ) ;
2021-04-05 18:48:46 -07:00
const page = await context . newPage ( ) ;
2020-12-21 11:47:13 -08:00
await page . goto ( 'http://non-existent.com/target.html' ) ;
2021-08-19 13:34:32 -07:00
expect ( auth ) . toBe ( 'Basic ' + Buffer . from ( 'user:' ) . toString ( 'base64' ) ) ;
expect ( await page . title ( ) ) . toBe ( 'Served by the proxy' ) ;
2021-04-05 18:48:46 -07:00
await context . close ( ) ;
2020-12-21 11:47:13 -08:00
} ) ;
2021-09-27 18:58:08 +02:00
it ( 'should isolate proxy credentials between contexts' , async ( { contextFactory , server , browserName , proxyServer } ) = > {
2021-08-19 13:34:32 -07:00
proxyServer . forwardTo ( server . PORT ) ;
let auth ;
proxyServer . setAuthHandler ( req = > {
auth = req . headers [ 'proxy-authorization' ] ;
return ! ! auth ;
2020-12-21 14:39:11 -08:00
} ) ;
{
2021-05-09 17:47:20 -07:00
const context = await contextFactory ( {
2021-08-19 13:34:32 -07:00
proxy : { server : ` localhost: ${ proxyServer . PORT } ` , username : 'user1' , password : 'secret1' }
2020-12-21 14:39:11 -08:00
} ) ;
const page = await context . newPage ( ) ;
await page . goto ( 'http://non-existent.com/target.html' ) ;
2021-08-19 13:34:32 -07:00
expect ( auth ) . toBe ( 'Basic ' + Buffer . from ( 'user1:secret1' ) . toString ( 'base64' ) ) ;
expect ( await page . title ( ) ) . toBe ( 'Served by the proxy' ) ;
2020-12-21 14:39:11 -08:00
await context . close ( ) ;
}
2021-08-19 13:34:32 -07:00
auth = undefined ;
2020-12-21 14:39:11 -08:00
{
2021-05-09 17:47:20 -07:00
const context = await contextFactory ( {
2021-08-19 13:34:32 -07:00
proxy : { server : ` localhost: ${ proxyServer . PORT } ` , username : 'user2' , password : 'secret2' }
2020-12-21 14:39:11 -08:00
} ) ;
const page = await context . newPage ( ) ;
await page . goto ( 'http://non-existent.com/target.html' ) ;
2021-08-19 13:34:32 -07:00
expect ( await page . title ( ) ) . toBe ( 'Served by the proxy' ) ;
expect ( auth ) . toBe ( 'Basic ' + Buffer . from ( 'user2:secret2' ) . toString ( 'base64' ) ) ;
2020-12-21 14:39:11 -08:00
await context . close ( ) ;
}
} ) ;
2023-09-29 10:45:31 -07:00
it ( 'should exclude patterns' , async ( { contextFactory , server , proxyServer } ) = > {
2021-08-19 13:34:32 -07:00
proxyServer . forwardTo ( server . PORT ) ;
2020-10-29 16:12:30 -07:00
// FYI: using long and weird domain names to avoid ATT DNS hijacking
// that resolves everything to some weird search results page.
//
// @see https://gist.github.com/CollinChaffin/24f6c9652efb3d6d5ef2f5502720ef00
2021-05-09 17:47:20 -07:00
const context = await contextFactory ( {
2021-08-19 13:34:32 -07:00
proxy : { server : ` localhost: ${ proxyServer . PORT } ` , bypass : '1.non.existent.domain.for.the.test, 2.non.existent.domain.for.the.test, .another.test' }
2020-10-29 16:12:30 -07:00
} ) ;
2023-06-30 13:08:18 -07:00
const nonFaviconUrls = ( ) = > {
return proxyServer . requestUrls . filter ( u = > ! u . includes ( 'favicon' ) ) ;
} ;
2020-10-29 16:12:30 -07:00
{
2023-09-29 10:45:31 -07:00
proxyServer . requestUrls = [ ] ;
const page = await context . newPage ( ) ;
await page . goto ( 'http://0.non.existent.domain.for.the.test/target.html' ) ;
expect ( proxyServer . requestUrls ) . toContain ( 'http://0.non.existent.domain.for.the.test/target.html' ) ;
expect ( await page . title ( ) ) . toBe ( 'Served by the proxy' ) ;
await page . close ( ) ;
}
{
proxyServer . requestUrls = [ ] ;
const page = await context . newPage ( ) ;
2020-10-29 16:12:30 -07:00
const error = await page . goto ( 'http://1.non.existent.domain.for.the.test/target.html' ) . catch ( e = > e ) ;
2023-06-30 13:08:18 -07:00
expect ( nonFaviconUrls ( ) ) . toEqual ( [ ] ) ;
2020-10-29 16:12:30 -07:00
expect ( error . message ) . toBeTruthy ( ) ;
2023-09-29 10:45:31 -07:00
await page . close ( ) ;
2020-10-29 16:12:30 -07:00
}
{
2023-09-29 10:45:31 -07:00
proxyServer . requestUrls = [ ] ;
const page = await context . newPage ( ) ;
2020-10-29 16:12:30 -07:00
const error = await page . goto ( 'http://2.non.existent.domain.for.the.test/target.html' ) . catch ( e = > e ) ;
2023-06-30 13:08:18 -07:00
expect ( nonFaviconUrls ( ) ) . toEqual ( [ ] ) ;
2020-10-29 16:12:30 -07:00
expect ( error . message ) . toBeTruthy ( ) ;
2023-09-29 10:45:31 -07:00
await page . close ( ) ;
2020-10-29 16:12:30 -07:00
}
{
2023-09-29 10:45:31 -07:00
proxyServer . requestUrls = [ ] ;
const page = await context . newPage ( ) ;
2020-10-29 16:12:30 -07:00
const error = await page . goto ( 'http://foo.is.the.another.test/target.html' ) . catch ( e = > e ) ;
2023-06-30 13:08:18 -07:00
expect ( nonFaviconUrls ( ) ) . toEqual ( [ ] ) ;
2020-10-29 16:12:30 -07:00
expect ( error . message ) . toBeTruthy ( ) ;
2023-09-29 10:45:31 -07:00
await page . close ( ) ;
2023-06-30 13:08:18 -07:00
}
2023-01-05 10:04:20 -08:00
2020-10-29 16:12:30 -07:00
{
2023-09-29 10:45:31 -07:00
proxyServer . requestUrls = [ ] ;
const page = await context . newPage ( ) ;
2020-10-29 16:12:30 -07:00
await page . goto ( 'http://3.non.existent.domain.for.the.test/target.html' ) ;
2023-06-30 13:08:18 -07:00
expect ( nonFaviconUrls ( ) ) . toContain ( 'http://3.non.existent.domain.for.the.test/target.html' ) ;
2020-10-29 16:12:30 -07:00
expect ( await page . title ( ) ) . toBe ( 'Served by the proxy' ) ;
2023-09-29 10:45:31 -07:00
await page . close ( ) ;
2020-10-29 16:12:30 -07:00
}
2021-04-05 18:48:46 -07:00
await context . close ( ) ;
2020-10-29 16:12:30 -07:00
} ) ;
2021-05-09 17:47:20 -07:00
it ( 'should use socks proxy' , async ( { contextFactory , socksPort } ) = > {
const context = await contextFactory ( {
2020-10-29 16:12:30 -07:00
proxy : { server : ` socks5://localhost: ${ socksPort } ` }
} ) ;
2021-04-05 18:48:46 -07:00
const page = await context . newPage ( ) ;
2020-10-29 16:12:30 -07:00
await page . goto ( 'http://non-existent.com' ) ;
expect ( await page . title ( ) ) . toBe ( 'Served by the SOCKS proxy' ) ;
2021-04-05 18:48:46 -07:00
await context . close ( ) ;
2020-10-29 16:12:30 -07:00
} ) ;
2021-05-09 17:47:20 -07:00
it ( 'should use socks proxy in second page' , async ( { contextFactory , socksPort } ) = > {
const context = await contextFactory ( {
2020-10-29 16:12:30 -07:00
proxy : { server : ` socks5://localhost: ${ socksPort } ` }
} ) ;
2021-04-05 18:48:46 -07:00
const page = await context . newPage ( ) ;
2020-10-29 16:12:30 -07:00
await page . goto ( 'http://non-existent.com' ) ;
expect ( await page . title ( ) ) . toBe ( 'Served by the SOCKS proxy' ) ;
2021-04-05 18:48:46 -07:00
const page2 = await context . newPage ( ) ;
2020-10-29 16:12:30 -07:00
await page2 . goto ( 'http://non-existent.com' ) ;
expect ( await page2 . title ( ) ) . toBe ( 'Served by the SOCKS proxy' ) ;
2021-04-05 18:48:46 -07:00
await context . close ( ) ;
2020-10-29 16:12:30 -07:00
} ) ;
2021-05-09 17:47:20 -07:00
it ( 'does launch without a port' , async ( { contextFactory } ) = > {
const context = await contextFactory ( {
2020-10-29 16:12:30 -07:00
proxy : { server : 'http://localhost' }
} ) ;
2021-04-05 18:48:46 -07:00
await context . close ( ) ;
2020-10-29 16:12:30 -07:00
} ) ;
