Skip to content

Commit 74fc8bd

Browse files
sbrannensbrannen
committed
Polish SimpleAliasRegistryTests
See gh-31348
1 parent d507590 commit 74fc8bd

File tree

1 file changed

+155
-77
lines changed

1 file changed

+155
-77
lines changed

‎spring-core/src/test/java/org/springframework/core/SimpleAliasRegistryTests.java

Lines changed: 155 additions & 77 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
/*
2-
* Copyright 2002-2021 the original author or authors.
2+
* Copyright 2002-2023 the original author or authors.
33
*
44
* Licensed under the Apache License, Version 2.0 (the "License");
55
* you may not use this file except in compliance with the License.
@@ -23,6 +23,7 @@
2323
import static org.assertj.core.api.Assertions.assertThat;
2424
import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
2525
import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
26+
import static org.assertj.core.api.Assertions.assertThatNoException;
2627
import static org.mockito.BDDMockito.given;
2728
import static org.mockito.BDDMockito.mock;
2829

@@ -35,119 +36,196 @@
3536
*/
3637
class SimpleAliasRegistryTests {
3738

39+
private static final String REAL_NAME = "real_name";
40+
private static final String NICKNAME = "nickname";
41+
private static final String NAME1 = "name1";
42+
private static final String NAME2 = "name2";
43+
private static final String NAME3 = "name3";
44+
private static final String NAME4 = "name4";
45+
private static final String NAME5 = "name5";
46+
private static final String ALIAS1 = "alias1";
47+
private static final String ALIAS2 = "alias2";
48+
private static final String ALIAS3 = "alias3";
49+
// TODO Change ALIAS4 to "alias4".
50+
// When ALIAS4 is "testAlias4", resolveAliasesWithComplexPlaceholderReplacement() passes.
51+
// If you change ALIAS4 to "alias4", resolveAliasesWithComplexPlaceholderReplacement() fails.
52+
// Those assertions pass for values such as "x", "xx", "xxx", and "xxxx" but fail with values
53+
// such as "xxxxx", "testAli", ...
54+
private static final String ALIAS4 = "testAlias4";
55+
private static final String ALIAS5 = "alias5";
56+
57+
3858
private final SimpleAliasRegistry registry = new SimpleAliasRegistry();
3959

60+
4061
@Test
4162
void aliasChaining() {
42-
registry.registerAlias("test", "testAlias");
43-
registry.registerAlias("testAlias", "testAlias2");
44-
registry.registerAlias("testAlias2", "testAlias3");
45-
46-
assertThat(registry.hasAlias("test", "testAlias")).isTrue();
47-
assertThat(registry.hasAlias("test", "testAlias2")).isTrue();
48-
assertThat(registry.hasAlias("test", "testAlias3")).isTrue();
49-
assertThat(registry.canonicalName("testAlias")).isEqualTo("test");
50-
assertThat(registry.canonicalName("testAlias2")).isEqualTo("test");
51-
assertThat(registry.canonicalName("testAlias3")).isEqualTo("test");
52-
63+
registerAlias(NAME1, ALIAS1);
64+
registerAlias(ALIAS1, ALIAS2);
65+
registerAlias(ALIAS2, ALIAS3);
66+
67+
assertHasAlias(NAME1, ALIAS1);
68+
assertHasAlias(NAME1, ALIAS2);
69+
assertHasAlias(NAME1, ALIAS3);
70+
assertThat(registry.canonicalName(ALIAS1)).isEqualTo(NAME1);
71+
assertThat(registry.canonicalName(ALIAS2)).isEqualTo(NAME1);
72+
assertThat(registry.canonicalName(ALIAS3)).isEqualTo(NAME1);
5373
}
5474

5575
@Test // SPR-17191
5676
void aliasChainingWithMultipleAliases() {
57-
registry.registerAlias("name", "alias_a");
58-
registry.registerAlias("name", "alias_b");
59-
assertThat(registry.hasAlias("name", "alias_a")).isTrue();
60-
assertThat(registry.hasAlias("name", "alias_b")).isTrue();
61-
62-
registry.registerAlias("real_name", "name");
63-
assertThat(registry.hasAlias("real_name", "name")).isTrue();
64-
assertThat(registry.hasAlias("real_name", "alias_a")).isTrue();
65-
assertThat(registry.hasAlias("real_name", "alias_b")).isTrue();
66-
67-
registry.registerAlias("name", "alias_c");
68-
assertThat(registry.hasAlias("real_name", "name")).isTrue();
69-
assertThat(registry.hasAlias("real_name", "alias_a")).isTrue();
70-
assertThat(registry.hasAlias("real_name", "alias_b")).isTrue();
71-
assertThat(registry.hasAlias("real_name", "alias_c")).isTrue();
77+
registerAlias(NAME1, ALIAS1);
78+
registerAlias(NAME1, ALIAS2);
79+
assertHasAlias(NAME1, ALIAS1);
80+
assertHasAlias(NAME1, ALIAS2);
81+
82+
registerAlias(REAL_NAME, NAME1);
83+
assertHasAlias(REAL_NAME, NAME1);
84+
assertHasAlias(REAL_NAME, ALIAS1);
85+
assertHasAlias(REAL_NAME, ALIAS2);
86+
87+
registerAlias(NAME1, ALIAS3);
88+
assertHasAlias(REAL_NAME, NAME1);
89+
assertHasAlias(REAL_NAME, ALIAS1);
90+
assertHasAlias(REAL_NAME, ALIAS2);
91+
assertHasAlias(REAL_NAME, ALIAS3);
7292
}
7393

7494
@Test
7595
void removeAlias() {
76-
registry.registerAlias("real_name", "nickname");
77-
assertThat(registry.hasAlias("real_name", "nickname")).isTrue();
96+
registerAlias(REAL_NAME, NICKNAME);
97+
assertHasAlias(REAL_NAME, NICKNAME);
7898

79-
registry.removeAlias("nickname");
80-
assertThat(registry.hasAlias("real_name", "nickname")).isFalse();
99+
registry.removeAlias(NICKNAME);
100+
assertDoesNotHaveAlias(REAL_NAME, NICKNAME);
81101
}
82102

83103
@Test
84104
void isAlias() {
85-
registry.registerAlias("real_name", "nickname");
86-
assertThat(registry.isAlias("nickname")).isTrue();
87-
assertThat(registry.isAlias("real_name")).isFalse();
88-
assertThat(registry.isAlias("fake")).isFalse();
105+
registerAlias(REAL_NAME, NICKNAME);
106+
assertThat(registry.isAlias(NICKNAME)).isTrue();
107+
assertThat(registry.isAlias(REAL_NAME)).isFalse();
108+
assertThat(registry.isAlias("bogus")).isFalse();
89109
}
90110

91111
@Test
92112
void getAliases() {
93-
registry.registerAlias("test", "testAlias1");
94-
assertThat(registry.getAliases("test")).containsExactly("testAlias1");
113+
assertThat(registry.getAliases(NAME1)).isEmpty();
95114

96-
registry.registerAlias("testAlias1", "testAlias2");
97-
registry.registerAlias("testAlias2", "testAlias3");
98-
assertThat(registry.getAliases("test")).containsExactlyInAnyOrder("testAlias1", "testAlias2", "testAlias3");
99-
assertThat(registry.getAliases("testAlias1")).containsExactlyInAnyOrder("testAlias2", "testAlias3");
100-
assertThat(registry.getAliases("testAlias2")).containsExactly("testAlias3");
115+
registerAlias(NAME1, ALIAS1);
116+
assertThat(registry.getAliases(NAME1)).containsExactly(ALIAS1);
101117

102-
assertThat(registry.getAliases("testAlias3")).isEmpty();
118+
registerAlias(ALIAS1, ALIAS2);
119+
registerAlias(ALIAS2, ALIAS3);
120+
assertThat(registry.getAliases(NAME1)).containsExactlyInAnyOrder(ALIAS1, ALIAS2, ALIAS3);
121+
assertThat(registry.getAliases(ALIAS1)).containsExactlyInAnyOrder(ALIAS2, ALIAS3);
122+
assertThat(registry.getAliases(ALIAS2)).containsExactly(ALIAS3);
123+
assertThat(registry.getAliases(ALIAS3)).isEmpty();
103124
}
104125

105126
@Test
106-
void testCheckForAliasCircle() {
107-
String name = "testName";
108-
String alias = "testAlias";
109-
registry.checkForAliasCircle(name, alias);
110-
registry.registerAlias(name, alias);
127+
void checkForAliasCircle() {
128+
// No aliases registered, so no cycles possible.
129+
assertThatNoException().isThrownBy(() -> registry.checkForAliasCircle(NAME1, ALIAS1));
130+
131+
// NAME1 -> ALIAS1
132+
registerAlias(NAME1, ALIAS1);
133+
134+
// No cycles possible.
135+
assertThatNoException().isThrownBy(() -> registry.checkForAliasCircle(NAME1, ALIAS1));
136+
111137
assertThatIllegalStateException()
112-
.isThrownBy(() -> registry.checkForAliasCircle(alias, name));
138+
// NAME1 -> ALIAS1 -> NAME1
139+
.isThrownBy(() -> registerAlias(ALIAS1, NAME1)) // internally invokes checkForAliasCircle()
140+
.withMessageContaining("'%s' is a direct or indirect alias for '%s'", ALIAS1, NAME1);
141+
142+
// NAME1 -> ALIAS1 -> ALIAS2
143+
registerAlias(ALIAS1, ALIAS2);
144+
assertThatIllegalStateException()
145+
// NAME1 -> ALIAS1 -> ALIAS2 -> NAME1
146+
.isThrownBy(() -> registerAlias(ALIAS2, NAME1)) // internally invokes checkForAliasCircle()
147+
.withMessageContaining("'%s' is a direct or indirect alias for '%s'", ALIAS2, NAME1);
148+
}
149+
150+
@Test
151+
void resolveAliasesPreconditions() {
152+
assertThatIllegalArgumentException().isThrownBy(() -> registry.resolveAliases(null));
113153
}
114154

115155
@Test
116-
void testResolveAliases() {
117-
assertThatIllegalArgumentException()
118-
.isThrownBy(() -> registry.resolveAliases(null));
156+
void resolveAliasesWithoutPlaceholderReplacement() {
157+
// Resolver returns input unmodified.
158+
StringValueResolver valueResolver = str -> str;
159+
160+
registerAlias(NAME1, ALIAS1);
161+
registerAlias(NAME1, ALIAS3);
162+
registerAlias(NAME2, ALIAS2);
163+
registerAlias(NAME2, ALIAS4);
164+
165+
registry.resolveAliases(valueResolver);
166+
assertThat(registry.getAliases(NAME1)).containsExactlyInAnyOrder(ALIAS1, ALIAS3);
167+
assertThat(registry.getAliases(NAME2)).containsExactlyInAnyOrder(ALIAS2, ALIAS4);
168+
169+
registry.removeAlias(ALIAS1);
170+
registry.resolveAliases(valueResolver);
171+
assertThat(registry.getAliases(NAME1)).containsExactly(ALIAS3);
172+
assertThat(registry.getAliases(NAME2)).containsExactlyInAnyOrder(ALIAS2, ALIAS4);
173+
}
119174

175+
@Test
176+
void resolveAliasesWithPlaceholderReplacement() {
120177
StringValueResolver mock = mock();
121178

122-
registry.registerAlias("testName1", "testAlias1");
123-
registry.registerAlias("testName2", "testAlias2");
124-
given(mock.resolveStringValue("testAlias2")).willReturn("anotherAlias2");
125-
given(mock.resolveStringValue("testName2")).willReturn("anotherName2");
179+
registerAlias(NAME1, ALIAS1);
180+
181+
given(mock.resolveStringValue(NAME1)).willReturn(NAME2);
182+
given(mock.resolveStringValue(ALIAS1)).willReturn(ALIAS2);
183+
126184
registry.resolveAliases(mock);
127-
assertThat(registry.getAliases("anotherName2")).containsExactly("anotherAlias2");
128-
129-
registry.registerAlias("testName3", "testAlias3");
130-
registry.registerAlias("testName4", "testAlias4");
131-
registry.registerAlias("testName5", "testAlias5");
132-
given(mock.resolveStringValue("testName5")).willReturn("testName5");
133-
given(mock.resolveStringValue("testAlias5")).willReturn("testAlias5");
134-
given(mock.resolveStringValue("testName3")).willReturn("testName4");
135-
given(mock.resolveStringValue("testAlias3")).willReturn("testAlias4");
136-
given(mock.resolveStringValue("testName4")).willReturn("testName4");
137-
given(mock.resolveStringValue("testAlias4")).willReturn("testAlias5");
138-
assertThatIllegalStateException()
139-
.isThrownBy(() -> registry.resolveAliases(mock));
185+
assertThat(registry.getAliases(NAME1)).isEmpty();
186+
assertThat(registry.getAliases(NAME2)).containsExactly(ALIAS2);
140187

141-
given(mock.resolveStringValue("testName4")).willReturn("testName5");
142-
given(mock.resolveStringValue("testAlias4")).willReturn("testAlias4");
143-
assertThatIllegalStateException()
144-
.isThrownBy(() -> registry.resolveAliases(mock));
188+
registry.removeAlias(ALIAS2);
189+
assertThat(registry.getAliases(NAME2)).isEmpty();
190+
}
191+
192+
@Test
193+
void resolveAliasesWithComplexPlaceholderReplacement() {
194+
StringValueResolver mock = mock();
195+
196+
registerAlias(NAME3, ALIAS3);
197+
registerAlias(NAME4, ALIAS4);
198+
registerAlias(NAME5, ALIAS5);
199+
200+
given(mock.resolveStringValue(NAME3)).willReturn(NAME4);
201+
given(mock.resolveStringValue(NAME4)).willReturn(NAME4);
202+
given(mock.resolveStringValue(NAME5)).willReturn(NAME5);
203+
given(mock.resolveStringValue(ALIAS3)).willReturn(ALIAS4);
204+
given(mock.resolveStringValue(ALIAS4)).willReturn(ALIAS5);
205+
given(mock.resolveStringValue(ALIAS5)).willReturn(ALIAS5);
206+
assertThatIllegalStateException().isThrownBy(() -> registry.resolveAliases(mock));
145207

146-
given(mock.resolveStringValue("testName4")).willReturn("testName4");
147-
given(mock.resolveStringValue("testAlias4")).willReturn("testAlias5");
208+
given(mock.resolveStringValue(NAME4)).willReturn(NAME5);
209+
given(mock.resolveStringValue(ALIAS4)).willReturn(ALIAS4);
210+
assertThatIllegalStateException().isThrownBy(() -> registry.resolveAliases(mock));
211+
212+
given(mock.resolveStringValue(NAME4)).willReturn(NAME4);
213+
given(mock.resolveStringValue(ALIAS4)).willReturn(ALIAS5);
148214
registry.resolveAliases(mock);
149-
assertThat(registry.getAliases("testName4")).containsExactly("testAlias4");
150-
assertThat(registry.getAliases("testName5")).containsExactly("testAlias5");
215+
assertThat(registry.getAliases(NAME4)).containsExactly(ALIAS4);
216+
assertThat(registry.getAliases(NAME5)).containsExactly(ALIAS5);
217+
}
218+
219+
private void registerAlias(String name, String alias) {
220+
registry.registerAlias(name, alias);
221+
}
222+
223+
private void assertHasAlias(String name, String alias) {
224+
assertThat(registry.hasAlias(name, alias)).isTrue();
225+
}
226+
227+
private void assertDoesNotHaveAlias(String name, String alias) {
228+
assertThat(registry.hasAlias(name, alias)).isFalse();
151229
}
152230

153231
}

0 commit comments

Comments
 (0)