Book a Demo!
CoCalc Logo Icon
StoreFeaturesDocsShareSupportNewsAboutPoliciesSign UpSign In
SeleniumHQ
GitHub Repository: SeleniumHQ/Selenium
 Path: blob/trunk/java/test/org/openqa/selenium/ProxyTest.java
1865 views
1
// Licensed to the Software Freedom Conservancy (SFC) under one

2
// or more contributor license agreements.  See the NOTICE file

3
// distributed with this work for additional information

4
// regarding copyright ownership.  The SFC licenses this file

5
// to you under the Apache License, Version 2.0 (the

6
// "License"); you may not use this file except in compliance

7
// with the License.  You may obtain a copy of the License at

8
//

9
//   http://www.apache.org/licenses/LICENSE-2.0

10
//

11
// Unless required by applicable law or agreed to in writing,

12
// software distributed under the License is distributed on an

13
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

14
// KIND, either express or implied.  See the License for the

15
// specific language governing permissions and limitations

16
// under the License.

17


18
package org.openqa.selenium;

19


20
import static org.assertj.core.api.Assertions.assertThat;

21
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;

22
import static org.openqa.selenium.Proxy.ProxyType.AUTODETECT;

23
import static org.openqa.selenium.Proxy.ProxyType.DIRECT;

24
import static org.openqa.selenium.Proxy.ProxyType.MANUAL;

25
import static org.openqa.selenium.Proxy.ProxyType.PAC;

26
import static org.openqa.selenium.Proxy.ProxyType.SYSTEM;

27
import static org.openqa.selenium.Proxy.ProxyType.UNSPECIFIED;

28
import static org.openqa.selenium.remote.CapabilityType.PROXY;

29


30
import java.util.Arrays;

31
import java.util.HashMap;

32
import java.util.Map;

33
import org.junit.jupiter.api.Disabled;

34
import org.junit.jupiter.api.Tag;

35
import org.junit.jupiter.api.Test;

36
import org.openqa.selenium.Proxy.ProxyType;

37
import org.openqa.selenium.json.Json;

38


39
@Tag("UnitTests")

40
class ProxyTest {

41


42
  @Test

43
  void testNotInitializedProxy() {

44
    Proxy proxy = new Proxy();

45


46
    assertThat(proxy.getProxyType()).isEqualTo(UNSPECIFIED);

47


48
    assertThat(proxy.getFtpProxy()).isNull();

49
    assertThat(proxy.getHttpProxy()).isNull();

50
    assertThat(proxy.getSslProxy()).isNull();

51
    assertThat(proxy.getSocksProxy()).isNull();

52
    assertThat(proxy.getSocksVersion()).isNull();

53
    assertThat(proxy.getSocksUsername()).isNull();

54
    assertThat(proxy.getSocksPassword()).isNull();

55
    assertThat(proxy.getNoProxy()).isNull();

56
    assertThat(proxy.getProxyAutoconfigUrl()).isNull();

57
    assertThat(proxy.isAutodetect()).isFalse();

58
  }

59


60
  @Test

61
  void testCanNotChangeAlreadyInitializedProxyType() {

62
    final Proxy proxy = new Proxy();

63
    proxy.setProxyType(DIRECT);

64


65
    assertThatExceptionOfType(IllegalStateException.class)

66
        .isThrownBy(() -> proxy.setAutodetect(true));

67


68
    assertThatExceptionOfType(IllegalStateException.class)

69
        .isThrownBy(() -> proxy.setSocksPassword(""));

70


71
    assertThatExceptionOfType(IllegalStateException.class)

72
        .isThrownBy(() -> proxy.setSocksUsername(""));

73


74
    assertThatExceptionOfType(IllegalStateException.class)

75
        .isThrownBy(() -> proxy.setSocksProxy(""));

76


77
    assertThatExceptionOfType(IllegalStateException.class).isThrownBy(() -> proxy.setFtpProxy(""));

78


79
    assertThatExceptionOfType(IllegalStateException.class).isThrownBy(() -> proxy.setHttpProxy(""));

80


81
    assertThatExceptionOfType(IllegalStateException.class).isThrownBy(() -> proxy.setNoProxy(""));

82


83
    assertThatExceptionOfType(IllegalStateException.class)

84
        .isThrownBy(() -> proxy.setProxyAutoconfigUrl(""));

85


86
    assertThatExceptionOfType(IllegalStateException.class)

87
        .isThrownBy(() -> proxy.setProxyType(SYSTEM));

88


89
    assertThatExceptionOfType(IllegalStateException.class).isThrownBy(() -> proxy.setSslProxy(""));

90


91
    final Proxy proxy2 = new Proxy();

92
    proxy2.setProxyType(AUTODETECT);

93


94
    assertThatExceptionOfType(IllegalStateException.class)

95
        .isThrownBy(() -> proxy2.setProxyType(SYSTEM));

96


97
    assertThatExceptionOfType(IllegalStateException.class)

98
        .isThrownBy(() -> proxy.setSocksVersion(5));

99
  }

100


101
  @Test

102
  void testManualProxy() {

103
    Proxy proxy = new Proxy();

104


105
    proxy

106
        .setHttpProxy("http.proxy:1234")

107
        .setFtpProxy("ftp.proxy")

108
        .setSslProxy("ssl.proxy")

109
        .setNoProxy("localhost,127.0.0.*")

110
        .setSocksProxy("socks.proxy:65555")

111
        .setSocksVersion(5)

112
        .setSocksUsername("test1")

113
        .setSocksPassword("test2");

114


115
    assertThat(proxy.getProxyType()).isEqualTo(MANUAL);

116
    assertThat(proxy.getFtpProxy()).isEqualTo("ftp.proxy");

117
    assertThat(proxy.getHttpProxy()).isEqualTo("http.proxy:1234");

118
    assertThat(proxy.getSslProxy()).isEqualTo("ssl.proxy");

119
    assertThat(proxy.getSocksProxy()).isEqualTo("socks.proxy:65555");

120
    assertThat(proxy.getSocksVersion()).isEqualTo(5);

121
    assertThat(proxy.getSocksUsername()).isEqualTo("test1");

122
    assertThat(proxy.getSocksPassword()).isEqualTo("test2");

123
    assertThat(proxy.getNoProxy()).isEqualTo("localhost,127.0.0.*");

124


125
    assertThat(proxy.getProxyAutoconfigUrl()).isNull();

126
    assertThat(proxy.isAutodetect()).isFalse();

127
  }

128


129
  @Test

130
  void testPACProxy() {

131
    Proxy proxy = new Proxy();

132
    proxy.setProxyAutoconfigUrl("http://aaa/bbb.pac");

133


134
    assertThat(proxy.getProxyType()).isEqualTo(PAC);

135
    assertThat(proxy.getProxyAutoconfigUrl()).isEqualTo("http://aaa/bbb.pac");

136


137
    assertThat(proxy.getFtpProxy()).isNull();

138
    assertThat(proxy.getHttpProxy()).isNull();

139
    assertThat(proxy.getSslProxy()).isNull();

140
    assertThat(proxy.getSocksProxy()).isNull();

141
    assertThat(proxy.getSocksVersion()).isNull();

142
    assertThat(proxy.getSocksUsername()).isNull();

143
    assertThat(proxy.getSocksPassword()).isNull();

144
    assertThat(proxy.getNoProxy()).isNull();

145
    assertThat(proxy.isAutodetect()).isFalse();

146
  }

147


148
  @Test

149
  void testAutodetectProxy() {

150
    Proxy proxy = new Proxy();

151
    proxy.setAutodetect(true);

152


153
    assertThat(proxy.getProxyType().name()).isEqualTo(AUTODETECT.name());

154
    assertThat(proxy.isAutodetect()).isTrue();

155


156
    assertThat(proxy.getFtpProxy()).isNull();

157
    assertThat(proxy.getHttpProxy()).isNull();

158
    assertThat(proxy.getSslProxy()).isNull();

159
    assertThat(proxy.getSocksProxy()).isNull();

160
    assertThat(proxy.getSocksVersion()).isNull();

161
    assertThat(proxy.getSocksUsername()).isNull();

162
    assertThat(proxy.getSocksPassword()).isNull();

163
    assertThat(proxy.getNoProxy()).isNull();

164
    assertThat(proxy.getProxyAutoconfigUrl()).isNull();

165
  }

166


167
  @Test

168
  void manualProxyFromMap() {

169
    Map<String, Object> proxyData = new HashMap<>();

170
    proxyData.put("proxyType", "manual");

171
    proxyData.put("httpProxy", "http.proxy:1234");

172
    proxyData.put("ftpProxy", "ftp.proxy");

173
    proxyData.put("sslProxy", "ssl.proxy");

174
    proxyData.put("noProxy", "localhost,127.0.0.*");

175
    proxyData.put("socksProxy", "socks.proxy:65555");

176
    proxyData.put("socksVersion", 5);

177
    proxyData.put("socksUsername", "test1");

178
    proxyData.put("socksPassword", "test2");

179


180
    Proxy proxy = new Proxy(proxyData);

181


182
    assertThat(proxy.getProxyType()).isEqualTo(MANUAL);

183
    assertThat(proxy.getFtpProxy()).isEqualTo("ftp.proxy");

184
    assertThat(proxy.getHttpProxy()).isEqualTo("http.proxy:1234");

185
    assertThat(proxy.getSslProxy()).isEqualTo("ssl.proxy");

186
    assertThat(proxy.getSocksProxy()).isEqualTo("socks.proxy:65555");

187
    assertThat(proxy.getSocksVersion()).isEqualTo(5);

188
    assertThat(proxy.getSocksUsername()).isEqualTo("test1");

189
    assertThat(proxy.getSocksPassword()).isEqualTo("test2");

190
    assertThat(proxy.getNoProxy()).isEqualTo("localhost,127.0.0.*");

191


192
    assertThat(proxy.getProxyAutoconfigUrl()).isNull();

193
    assertThat(proxy.isAutodetect()).isFalse();

194
  }

195


196
  @Test

197
  void longSocksVersionFromMap() {

198
    Map<String, Object> proxyData = new HashMap<>();

199
    long l = 5;

200
    proxyData.put("proxyType", "manual");

201
    proxyData.put("httpProxy", "http.proxy:1234");

202
    proxyData.put("ftpProxy", "ftp.proxy");

203
    proxyData.put("sslProxy", "ssl.proxy");

204
    proxyData.put("noProxy", "localhost,127.0.0.*");

205
    proxyData.put("socksProxy", "socks.proxy:65555");

206
    proxyData.put("socksVersion", l);

207
    proxyData.put("socksUsername", "test1");

208
    proxyData.put("socksPassword", "test2");

209


210
    Proxy proxy = new Proxy(proxyData);

211


212
    assertThat(proxy.getSocksVersion()).isEqualTo(5);

213
  }

214


215
  @Test

216
  void manualProxyToJson() {

217
    Proxy proxy = new Proxy();

218
    proxy.setProxyType(ProxyType.MANUAL);

219
    proxy.setHttpProxy("http.proxy:1234");

220
    proxy.setFtpProxy("ftp.proxy");

221
    proxy.setSslProxy("ssl.proxy");

222
    proxy.setNoProxy("localhost,127.0.0.*");

223
    proxy.setSocksProxy("socks.proxy:65555");

224
    proxy.setSocksVersion(5);

225
    proxy.setSocksUsername("test1");

226
    proxy.setSocksPassword("test2");

227


228
    Map<String, Object> json = proxy.toJson();

229


230
    assertThat(json.get("proxyType")).isEqualTo("manual");

231
    assertThat(json.get("ftpProxy")).isEqualTo("ftp.proxy");

232
    assertThat(json.get("httpProxy")).isEqualTo("http.proxy:1234");

233
    assertThat(json.get("sslProxy")).isEqualTo("ssl.proxy");

234
    assertThat(json.get("socksProxy")).isEqualTo("socks.proxy:65555");

235
    assertThat(json.get("socksVersion")).isEqualTo(5);

236
    assertThat(json.get("socksUsername")).isEqualTo("test1");

237
    assertThat(json.get("socksPassword")).isEqualTo("test2");

238
    assertThat(json.get("noProxy")).isEqualTo(Arrays.asList("localhost", "127.0.0.*"));

239
    assertThat(json.entrySet()).hasSize(9);

240
  }

241


242
  @Test

243
  void pacProxyFromMap() {

244
    Map<String, String> proxyData = new HashMap<>();

245
    proxyData.put("proxyType", "PAC");

246
    proxyData.put("proxyAutoconfigUrl", "http://aaa/bbb.pac");

247


248
    Proxy proxy = new Proxy(proxyData);

249


250
    assertThat(proxy.getProxyType()).isEqualTo(PAC);

251
    assertThat(proxy.getProxyAutoconfigUrl()).isEqualTo("http://aaa/bbb.pac");

252


253
    assertThat(proxy.getFtpProxy()).isNull();

254
    assertThat(proxy.getHttpProxy()).isNull();

255
    assertThat(proxy.getSslProxy()).isNull();

256
    assertThat(proxy.getSocksProxy()).isNull();

257
    assertThat(proxy.getSocksVersion()).isNull();

258
    assertThat(proxy.getSocksUsername()).isNull();

259
    assertThat(proxy.getSocksPassword()).isNull();

260
    assertThat(proxy.getNoProxy()).isNull();

261
    assertThat(proxy.isAutodetect()).isFalse();

262
  }

263


264
  @Test

265
  void pacProxyToJson() {

266
    Proxy proxy = new Proxy();

267
    proxy.setProxyType(ProxyType.PAC);

268
    proxy.setProxyAutoconfigUrl("http://aaa/bbb.pac");

269


270
    Map<String, Object> json = proxy.toJson();

271


272
    assertThat(json.get("proxyType")).isEqualTo("pac");

273
    assertThat(json.get("proxyAutoconfigUrl")).isEqualTo("http://aaa/bbb.pac");

274
    assertThat(json.entrySet()).hasSize(2);

275
  }

276


277
  @Test

278
  void autodetectProxyFromMap() {

279
    Map<String, Object> proxyData = new HashMap<>();

280
    proxyData.put("proxyType", "AUTODETECT");

281
    proxyData.put("autodetect", true);

282


283
    Proxy proxy = new Proxy(proxyData);

284


285
    assertThat(proxy.getProxyType()).isEqualTo(AUTODETECT);

286
    assertThat(proxy.isAutodetect()).isTrue();

287


288
    assertThat(proxy.getFtpProxy()).isNull();

289
    assertThat(proxy.getHttpProxy()).isNull();

290
    assertThat(proxy.getSslProxy()).isNull();

291
    assertThat(proxy.getSocksProxy()).isNull();

292
    assertThat(proxy.getSocksVersion()).isNull();

293
    assertThat(proxy.getSocksUsername()).isNull();

294
    assertThat(proxy.getSocksPassword()).isNull();

295
    assertThat(proxy.getNoProxy()).isNull();

296
    assertThat(proxy.getProxyAutoconfigUrl()).isNull();

297
  }

298


299
  @Test

300
  void autodetectProxyToJson() {

301
    Proxy proxy = new Proxy();

302
    proxy.setProxyType(ProxyType.AUTODETECT);

303
    proxy.setAutodetect(true);

304


305
    Map<String, ?> json = proxy.toJson();

306


307
    assertThat(json.get("proxyType")).isEqualTo("autodetect");

308
    assertThat((Boolean) json.get("autodetect")).isTrue();

309
    assertThat(json.entrySet()).hasSize(2);

310
  }

311


312
  @Test

313
  void systemProxyFromMap() {

314
    Map<String, String> proxyData = new HashMap<>();

315
    proxyData.put("proxyType", "system");

316


317
    Proxy proxy = new Proxy(proxyData);

318


319
    assertThat(proxy.getProxyType()).isEqualTo(SYSTEM);

320


321
    assertThat(proxy.getFtpProxy()).isNull();

322
    assertThat(proxy.getHttpProxy()).isNull();

323
    assertThat(proxy.getSslProxy()).isNull();

324
    assertThat(proxy.getSocksProxy()).isNull();

325
    assertThat(proxy.getSocksVersion()).isNull();

326
    assertThat(proxy.getSocksUsername()).isNull();

327
    assertThat(proxy.getSocksPassword()).isNull();

328
    assertThat(proxy.getNoProxy()).isNull();

329
    assertThat(proxy.isAutodetect()).isFalse();

330
    assertThat(proxy.getProxyAutoconfigUrl()).isNull();

331
  }

332


333
  @Test

334
  void systemProxyToJson() {

335
    Proxy proxy = new Proxy();

336
    proxy.setProxyType(ProxyType.SYSTEM);

337


338
    Map<String, Object> json = proxy.toJson();

339


340
    assertThat(json.get("proxyType")).isEqualTo("system");

341
    assertThat(json.entrySet()).hasSize(1);

342
  }

343


344
  @Test

345
  void directProxyFromMap() {

346
    Map<String, String> proxyData = new HashMap<>();

347
    proxyData.put("proxyType", "DIRECT");

348


349
    Proxy proxy = new Proxy(proxyData);

350


351
    assertThat(proxy.getProxyType()).isEqualTo(DIRECT);

352


353
    assertThat(proxy.getFtpProxy()).isNull();

354
    assertThat(proxy.getHttpProxy()).isNull();

355
    assertThat(proxy.getSslProxy()).isNull();

356
    assertThat(proxy.getSocksProxy()).isNull();

357
    assertThat(proxy.getSocksVersion()).isNull();

358
    assertThat(proxy.getSocksUsername()).isNull();

359
    assertThat(proxy.getSocksPassword()).isNull();

360
    assertThat(proxy.getNoProxy()).isNull();

361
    assertThat(proxy.isAutodetect()).isFalse();

362
    assertThat(proxy.getProxyAutoconfigUrl()).isNull();

363
  }

364


365
  @Test

366
  void directProxyToJson() {

367
    Proxy proxy = new Proxy();

368
    proxy.setProxyType(ProxyType.DIRECT);

369


370
    Map<String, Object> json = proxy.toJson();

371


372
    assertThat(json.get("proxyType")).isEqualTo("direct");

373
    assertThat(json.entrySet()).hasSize(1);

374
  }

375


376
  @Test

377
  void constructingWithNullKeysWorksAsExpected() {

378
    Map<String, String> rawProxy = new HashMap<>();

379
    rawProxy.put("ftpProxy", null);

380
    rawProxy.put("httpProxy", "http://www.example.com");

381
    rawProxy.put("autodetect", null);

382
    Capabilities caps = new ImmutableCapabilities(PROXY, rawProxy);

383


384
    Proxy proxy = Proxy.extractFrom(caps);

385


386
    assertThat(proxy.getFtpProxy()).isNull();

387
    assertThat(proxy.isAutodetect()).isFalse();

388
    assertThat(proxy.getHttpProxy()).isEqualTo("http://www.example.com");

389
  }

390


391
  @Test

392
  @Disabled

393
  public void serializesAndDeserializesWithoutError() {

394
    Proxy proxy = new Proxy();

395
    proxy.setProxyAutoconfigUrl("http://www.example.com/config.pac");

396


397
    Capabilities caps = new ImmutableCapabilities(PROXY, proxy);

398


399
    String rawJson = new Json().toJson(caps);

400
    Capabilities converted = new Json().toType(rawJson, Capabilities.class);

401


402
    Object returnedProxy = converted.getCapability(PROXY);

403
    assertThat(returnedProxy).isInstanceOf(Proxy.class);

404
  }

405
}

406


407