Skip to content

Commit 9eaaba9

Browse files
kimsunghyun1995tishun
kimsunghyun1995
and
tishun
authored
chore: deprecated withPassword(String) method (#3328) (#3350)
* Remove deprecated withPassword(String) method * Completely remove all deprecated logic in the RedisURI class --------- Co-authored-by: Tihomir Mateev <[email protected]>
1 parent 9c03e5d commit 9eaaba9

9 files changed

+229
-248
lines changed

‎src/main/java/io/lettuce/core/RedisURI.java‎

Lines changed: 79 additions & 165 deletions
Large diffs are not rendered by default.

‎src/test/java/io/lettuce/core/ClientOptionsIntegrationTests.java‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -164,7 +164,7 @@ void testHitRequestQueueLimitReconnectWithUriAuth() {
164164
;
165165

166166
RedisURI redisURI = RedisURI.create(host, port);
167-
redisURI.setPassword(passwd);
167+
redisURI.setAuthentication(passwd);
168168

169169
RedisAsyncCommands<String, String> connection = client.connect(redisURI).async();
170170
testHitRequestQueueLimit(connection);
@@ -180,7 +180,7 @@ void testHitRequestQueueLimitReconnectWithUriAuthPingCommand() {
180180
.timeoutOptions(TimeoutOptions.builder().timeoutCommands(false).build()).build());
181181

182182
RedisURI redisURI = RedisURI.create(host, port);
183-
redisURI.setPassword(passwd);
183+
redisURI.setAuthentication(passwd);
184184

185185
RedisAsyncCommands<String, String> connection = client.connect(redisURI).async();
186186
testHitRequestQueueLimit(connection);

‎src/test/java/io/lettuce/core/RedisURIBuilderUnitTests.java‎

Lines changed: 97 additions & 56 deletions
Original file line numberDiff line numberDiff line change
@@ -21,6 +21,7 @@
2121

2222
import static io.lettuce.TestTags.UNIT_TEST;
2323
import static org.assertj.core.api.Assertions.*;
24+
import static org.assertj.core.api.Assertions.assertThat;
2425

2526
import java.io.File;
2627
import java.io.IOException;
@@ -30,6 +31,8 @@
3031
import org.junit.jupiter.api.Test;
3132
import org.junit.jupiter.api.condition.DisabledOnOs;
3233
import org.junit.jupiter.api.condition.OS;
34+
import reactor.core.publisher.Mono;
35+
import reactor.test.StepVerifier;
3336

3437
/**
3538
* Unit tests for {@link RedisURI.Builder}.
@@ -117,27 +120,37 @@ void redisFromUrl() {
117120
assertThat(result.getSentinels()).isEmpty();
118121
assertThat(result.getHost()).isEqualTo("localhost");
119122
assertThat(result.getPort()).isEqualTo(RedisURI.DEFAULT_REDIS_PORT);
120-
assertThat(result.getPassword()).isEqualTo("password".toCharArray());
123+
StepVerifier.create(result.getCredentialsProvider().resolveCredentials()).assertNext(credentials -> {
124+
assertThat(credentials.getUsername()).isNull();
125+
assertThat(credentials.getPassword()).isEqualTo("password".toCharArray());
126+
}).verifyComplete();
121127
assertThat(result.getDatabase()).isEqualTo(21);
122128
assertThat(result.isSsl()).isFalse();
123129
}
124130

125131
@Test
126132
void redisFromUrlNoPassword() {
127133
RedisURI redisURI = RedisURI.create("redis://localhost:1234/5");
128-
assertThat(redisURI.getPassword()).isNull();
129-
assertThat(redisURI.getUsername()).isNull();
134+
StepVerifier.create(redisURI.getCredentialsProvider().resolveCredentials()).assertNext(credentials -> {
135+
assertThat(credentials.getUsername()).isNull();
136+
assertThat(credentials.getPassword()).isNull();
137+
}).verifyComplete();
130138

131139
redisURI = RedisURI.create("redis://h:@localhost.com:14589");
132-
assertThat(redisURI.getPassword()).isNull();
133-
assertThat(redisURI.getUsername()).isNull();
140+
StepVerifier.create(redisURI.getCredentialsProvider().resolveCredentials()).assertNext(credentials -> {
141+
assertThat(credentials.getUsername()).isNull();
142+
assertThat(credentials.getPassword()).isNull();
143+
}).verifyComplete();
134144
}
135145

136146
@Test
137147
void redisFromUrlPassword() {
138148
RedisURI redisURI = RedisURI.create("redis://h:[email protected]:14589");
139-
assertThat(redisURI.getPassword()).isEqualTo("password".toCharArray());
140-
assertThat(redisURI.getUsername()).isEqualTo("h");
149+
150+
StepVerifier.create(redisURI.getCredentialsProvider().resolveCredentials()).assertNext(credentials -> {
151+
assertThat(credentials.getUsername()).isEqualTo("h");
152+
assertThat(credentials.getPassword()).isEqualTo("password".toCharArray());
153+
}).verifyComplete();
141154
}
142155

143156
@Test
@@ -168,8 +181,11 @@ void redisSslFromUrl() {
168181
assertThat(result.getSentinels()).isEmpty();
169182
assertThat(result.getHost()).isEqualTo("localhost");
170183
assertThat(result.getPort()).isEqualTo(RedisURI.DEFAULT_REDIS_PORT);
171-
assertThat(result.getPassword()).isEqualTo("password".toCharArray());
172-
assertThat(result.getUsername()).isNull();
184+
StepVerifier.create(result.getCredentialsProvider().resolveCredentials()).assertNext(credentials -> {
185+
assertThat(credentials.getUsername()).isNull();
186+
assertThat(credentials.getPassword()).isEqualTo("password".toCharArray());
187+
}).verifyComplete();
188+
173189
assertThat(result.isSsl()).isTrue();
174190
}
175191

@@ -180,17 +196,23 @@ void redisSentinelFromUrl() {
180196
assertThat(result.getSentinels()).hasSize(1);
181197
assertThat(result.getHost()).isNull();
182198
assertThat(result.getPort()).isEqualTo(RedisURI.DEFAULT_REDIS_PORT);
183-
assertThat(result.getPassword()).isEqualTo("password".toCharArray());
184199
assertThat(result.getSentinelMasterId()).isEqualTo("master");
185200
assertThat(result.toString()).contains("master");
201+
StepVerifier.create(result.getCredentialsProvider().resolveCredentials()).assertNext(credentials -> {
202+
assertThat(credentials.getUsername()).isNull();
203+
assertThat(credentials.getPassword()).isEqualTo("password".toCharArray());
204+
}).verifyComplete();
186205

187206
result = RedisURI.create(RedisURI.URI_SCHEME_REDIS_SENTINEL + "://password@host1:1,host2:3423,host3/1#master");
188207

189208
assertThat(result.getSentinels()).hasSize(3);
190209
assertThat(result.getHost()).isNull();
191210
assertThat(result.getPort()).isEqualTo(RedisURI.DEFAULT_REDIS_PORT);
192-
assertThat(result.getPassword()).isEqualTo("password".toCharArray());
193211
assertThat(result.getSentinelMasterId()).isEqualTo("master");
212+
StepVerifier.create(result.getCredentialsProvider().resolveCredentials()).assertNext(credentials -> {
213+
assertThat(credentials.getUsername()).isNull();
214+
assertThat(credentials.getPassword()).isEqualTo("password".toCharArray());
215+
}).verifyComplete();
194216

195217
RedisURI sentinel1 = result.getSentinels().get(0);
196218
assertThat(sentinel1.getPort()).isEqualTo(1);
@@ -211,7 +233,10 @@ void withAuthenticatedSentinel() {
211233
RedisURI result = RedisURI.Builder.sentinel("host", 1234, "master", "foo").build();
212234

213235
RedisURI sentinel = result.getSentinels().get(0);
214-
assertThat(new String(sentinel.getPassword())).isEqualTo("foo");
236+
StepVerifier.create(sentinel.getCredentialsProvider().resolveCredentials()).assertNext(credentials -> {
237+
assertThat(credentials.getUsername()).isNull();
238+
assertThat(credentials.getPassword()).isEqualTo("foo".toCharArray());
239+
}).verifyComplete();
215240
}
216241

217242
@Test
@@ -221,35 +246,67 @@ void withTlsSentinel() {
221246
.withVerifyPeer(false).build();
222247

223248
RedisURI sentinel = result.getSentinels().get(0);
224-
assertThat(new String(sentinel.getPassword())).isEqualTo("foo");
225249
assertThat(sentinel.isSsl()).isTrue();
226250
assertThat(sentinel.isStartTls()).isTrue();
227251
assertThat(sentinel.isVerifyPeer()).isFalse();
252+
253+
StepVerifier.create(sentinel.getCredentialsProvider().resolveCredentials()).assertNext(credentials -> {
254+
assertThat(credentials.getUsername()).isNull();
255+
assertThat(credentials.getPassword()).isEqualTo("foo".toCharArray());
256+
}).verifyComplete();
228257
}
229258

230259
@Test
231260
void withAuthenticatedSentinelUri() {
232261

233262
RedisURI sentinel = new RedisURI("host", 1234, Duration.ZERO);
234-
sentinel.setPassword("bar");
263+
sentinel.setAuthentication("bar".toCharArray());
235264
RedisURI result = RedisURI.Builder.sentinel("host", 1234, "master").withSentinel(sentinel).build();
236265

237-
assertThat(result.getSentinels().get(0).getPassword()).isNull();
238-
assertThat(new String(result.getSentinels().get(1).getPassword())).isEqualTo("bar");
266+
StepVerifier.create(result.getSentinels().get(0).getCredentialsProvider().resolveCredentials())
267+
.assertNext(credentials -> {
268+
assertThat(credentials.getUsername()).isNull();
269+
assertThat(credentials.getPassword()).isNull();
270+
}).verifyComplete();
271+
272+
StepVerifier.create(result.getSentinels().get(1).getCredentialsProvider().resolveCredentials())
273+
.assertNext(credentials -> {
274+
assertThat(credentials.getUsername()).isNull();
275+
assertThat(credentials.getPassword()).isEqualTo("bar".toCharArray());
276+
}).verifyComplete();
239277
}
240278

241279
@Test
242280
void withAuthenticatedSentinelWithSentinel() {
243281

244282
RedisURI result = RedisURI.Builder.sentinel("host", 1234, "master", "foo").withSentinel("bar").build();
245283

246-
assertThat(new String(result.getSentinels().get(0).getPassword())).isEqualTo("foo");
247-
assertThat(new String(result.getSentinels().get(1).getPassword())).isEqualTo("foo");
248-
249-
result = RedisURI.Builder.sentinel("host", 1234, "master", "foo").withSentinel("bar", 1234, "baz").build();
250-
251-
assertThat(new String(result.getSentinels().get(0).getPassword())).isEqualTo("foo");
252-
assertThat(new String(result.getSentinels().get(1).getPassword())).isEqualTo("baz");
284+
StepVerifier.create(result.getSentinels().get(0).getCredentialsProvider().resolveCredentials())
285+
.assertNext(credentials -> {
286+
assertThat(credentials.getUsername()).isNull();
287+
assertThat(credentials.getPassword()).isEqualTo("foo".toCharArray());
288+
}).verifyComplete();
289+
290+
StepVerifier.create(result.getSentinels().get(1).getCredentialsProvider().resolveCredentials())
291+
.assertNext(credentials -> {
292+
assertThat(credentials.getUsername()).isNull();
293+
assertThat(credentials.getPassword()).isNull();
294+
}).verifyComplete();
295+
296+
result = RedisURI.Builder.sentinel("host", 1234, "master").withPassword("foo".toCharArray())
297+
.withSentinel("bar", 1234, "baz").build();
298+
299+
StepVerifier.create(result.getSentinels().get(0).getCredentialsProvider().resolveCredentials())
300+
.assertNext(credentials -> {
301+
assertThat(credentials.getUsername()).isNull();
302+
assertThat(credentials.getPassword()).isNull();
303+
}).verifyComplete();
304+
305+
StepVerifier.create(result.getSentinels().get(1).getCredentialsProvider().resolveCredentials())
306+
.assertNext(credentials -> {
307+
assertThat(credentials.getUsername()).isNull();
308+
assertThat(credentials.getPassword()).isEqualTo("baz".toCharArray());
309+
}).verifyComplete();
253310
}
254311

255312
@Test
@@ -280,10 +337,14 @@ void redisSocket() throws IOException {
280337

281338
assertThat(result.getSocket()).isEqualTo(file.getCanonicalPath());
282339
assertThat(result.getSentinels()).isEmpty();
283-
assertThat(result.getPassword()).isNull();
284340
assertThat(result.getHost()).isNull();
285341
assertThat(result.getPort()).isEqualTo(RedisURI.DEFAULT_REDIS_PORT);
286342
assertThat(result.isSsl()).isFalse();
343+
344+
StepVerifier.create(result.getCredentialsProvider().resolveCredentials()).assertNext(credentials -> {
345+
assertThat(credentials.getUsername()).isNull();
346+
assertThat(credentials.getPassword()).isNull();
347+
}).verifyComplete();
287348
}
288349

289350
@Test
@@ -294,10 +355,14 @@ void redisSocketWithPassword() throws IOException {
294355

295356
assertThat(result.getSocket()).isEqualTo(file.getCanonicalPath());
296357
assertThat(result.getSentinels()).isEmpty();
297-
assertThat(result.getPassword()).isEqualTo("password".toCharArray());
298358
assertThat(result.getHost()).isNull();
299359
assertThat(result.getPort()).isEqualTo(RedisURI.DEFAULT_REDIS_PORT);
300360
assertThat(result.isSsl()).isFalse();
361+
362+
StepVerifier.create(result.getCredentialsProvider().resolveCredentials()).assertNext(credentials -> {
363+
assertThat(credentials.getUsername()).isNull();
364+
assertThat(credentials.getPassword()).isEqualTo("password".toCharArray());
365+
}).verifyComplete();
301366
}
302367

303368
@Test
@@ -315,31 +380,6 @@ void shouldApplySslSettings() {
315380
assertThat(target.isStartTls()).isTrue();
316381
}
317382

318-
@Test
319-
void shouldApplyAuthentication() {
320-
321-
RedisURI source = new RedisURI();
322-
source.setUsername("foo");
323-
source.setPassword("bar");
324-
325-
RedisURI target = RedisURI.builder().withHost("localhost").withAuthentication(source).build();
326-
327-
assertThat(target.getUsername()).isEqualTo("foo");
328-
assertThat(target.getPassword()).isEqualTo("bar".toCharArray());
329-
330-
RedisCredentialsProvider provider = RedisCredentialsProvider
331-
.from(() -> RedisCredentials.just("suppliedUsername", "suppliedPassword".toCharArray()));
332-
333-
RedisURI sourceCp = new RedisURI();
334-
sourceCp.setCredentialsProvider(provider);
335-
336-
RedisURI targetCp = RedisURI.builder().withHost("localhost").withAuthentication(sourceCp).build();
337-
338-
assertThat(targetCp.getUsername()).isNull();
339-
assertThat(targetCp.getPassword()).isNull();
340-
assertThat(sourceCp.getCredentialsProvider()).isEqualTo(targetCp.getCredentialsProvider());
341-
}
342-
343383
@Test
344384
void shouldInitializeBuilder() {
345385

@@ -350,21 +390,17 @@ void shouldInitializeBuilder() {
350390
source.setClientName("foo");
351391
source.setLibraryName("lib");
352392
source.setLibraryVersion("libver");
353-
source.setUsername("foo");
354-
source.setPassword("bar");
393+
source.setAuthentication("foo", "bar");
355394
source.setDatabase(4);
356395
source.setSsl(true);
357396
source.setVerifyPeer(false);
358397
source.setStartTls(true);
359398

360399
RedisURI target = RedisURI.builder(source).build();
361-
362-
source.setPassword("baz");
400+
target.setAuthentication("baz");
363401

364402
assertThat(target.getHost()).isEqualTo(source.getHost());
365403
assertThat(target.getPort()).isEqualTo(source.getPort());
366-
assertThat(target.getUsername()).isEqualTo(source.getUsername());
367-
assertThat(target.getPassword()).isEqualTo("bar".toCharArray());
368404
assertThat(target.getTimeout()).isEqualTo(source.getTimeout());
369405
assertThat(target.getClientName()).isEqualTo(source.getClientName());
370406
assertThat(target.getLibraryName()).isEqualTo(source.getLibraryName());
@@ -374,6 +410,11 @@ void shouldInitializeBuilder() {
374410
assertThat(target.isStartTls()).isEqualTo(source.isStartTls());
375411
assertThat(target.isSsl()).isEqualTo(source.isSsl());
376412
assertThat(target.isVerifyPeer()).isEqualTo(source.isVerifyPeer());
413+
414+
StepVerifier.create(target.getCredentialsProvider().resolveCredentials()).assertNext(credentials -> {
415+
assertThat(credentials.getUsername()).isNull();
416+
assertThat(credentials.getPassword()).isEqualTo("baz".toCharArray());
417+
}).verifyComplete();
377418
}
378419

379420
@Test

‎src/test/java/io/lettuce/core/RedisURIUnitTests.java‎

Lines changed: 25 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -31,11 +31,14 @@
3131
import java.util.Set;
3232
import java.util.concurrent.TimeUnit;
3333

34+
import io.lettuce.core.cluster.ClusterTestSettings;
35+
import io.lettuce.test.settings.TestSettings;
3436
import org.junit.jupiter.api.Tag;
3537
import org.junit.jupiter.api.Test;
3638

3739
import io.lettuce.core.internal.LettuceSets;
3840
import reactor.core.publisher.Mono;
41+
import reactor.test.StepVerifier;
3942

4043
/**
4144
* Unit tests for {@link RedisURI}
@@ -211,13 +214,19 @@ void escapeCharacterParsingTest() throws UnsupportedEncodingException {
211214
String uri = "redis-sentinel://" + translatedPassword + "@h1:1234,h2:1234,h3:1234/0?sentinelMasterId=masterId";
212215
RedisURI redisURI = RedisURI.create(uri);
213216
assertThat(redisURI.getSentinels().get(0).getHost()).isEqualTo("h1");
214-
assertThat(redisURI.getPassword()).isEqualTo(password.toCharArray());
217+
StepVerifier.create(redisURI.getCredentialsProvider().resolveCredentials()).assertNext(credentials -> {
218+
assertThat(credentials.getUsername()).isNull();
219+
assertThat(credentials.getPassword()).isEqualTo(password.toCharArray());
220+
}).verifyComplete();
215221

216222
// redis standalone
217223
uri = "redis://" + translatedPassword + "@h1:1234/0";
218224
redisURI = RedisURI.create(uri);
219225
assertThat(redisURI.getHost()).isEqualTo("h1");
220-
assertThat(redisURI.getPassword()).isEqualTo(password.toCharArray());
226+
StepVerifier.create(redisURI.getCredentialsProvider().resolveCredentials()).assertNext(credentials -> {
227+
assertThat(credentials.getUsername()).isNull();
228+
assertThat(credentials.getPassword()).isEqualTo(password.toCharArray());
229+
}).verifyComplete();
221230
}
222231

223232
@Test
@@ -341,22 +350,23 @@ void shouldApplySslSettings() {
341350
void shouldApplyAuthentication() {
342351

343352
RedisURI source = new RedisURI();
344-
source.setUsername("foo");
345-
source.setPassword("bar");
353+
source.setAuthentication("foo", "bar".toCharArray());
346354

347355
RedisURI target = new RedisURI();
348-
349356
target.applyAuthentication(source);
350357

351-
assertThat(target.getUsername()).isEqualTo("foo");
352-
assertThat(target.getPassword()).isEqualTo("bar".toCharArray());
353-
354-
source.setUsername(null);
358+
StepVerifier.create(target.getCredentialsProvider().resolveCredentials()).assertNext(credentials -> {
359+
assertThat(credentials.getUsername()).isEqualTo("foo");
360+
assertThat(credentials.getPassword()).isEqualTo("bar".toCharArray());
361+
}).verifyComplete();
355362

363+
source.setCredentialsProvider(new StaticCredentialsProvider(null, "bar".toCharArray()));
356364
target.applyAuthentication(source);
357365

358-
assertThat(target.getUsername()).isNull();
359-
assertThat(target.getPassword()).isEqualTo("bar".toCharArray());
366+
StepVerifier.create(target.getCredentialsProvider().resolveCredentials()).assertNext(credentials -> {
367+
assertThat(credentials.getUsername()).isNull();
368+
assertThat(credentials.getPassword()).isEqualTo("bar".toCharArray());
369+
}).verifyComplete();
360370

361371
RedisCredentialsProvider provider = () -> Mono
362372
.just(RedisCredentials.just("suppliedUsername", "suppliedPassword".toCharArray()));
@@ -367,8 +377,10 @@ void shouldApplyAuthentication() {
367377
RedisURI targetCp = new RedisURI();
368378
targetCp.applyAuthentication(sourceCp);
369379

370-
assertThat(targetCp.getUsername()).isNull();
371-
assertThat(targetCp.getPassword()).isNull();
380+
StepVerifier.create(targetCp.getCredentialsProvider().resolveCredentials()).assertNext(credentials -> {
381+
assertThat(credentials.getUsername()).isEqualTo("suppliedUsername");
382+
assertThat(credentials.getPassword()).isEqualTo("suppliedPassword".toCharArray());
383+
}).verifyComplete();
372384
assertThat(sourceCp.getCredentialsProvider()).isEqualTo(targetCp.getCredentialsProvider());
373385
}
374386

0 commit comments

Comments
 (0)