Skip to content

Commit 98b8480

Browse files
committed
test: fixed failing test
1 parent 3a6cfae commit 98b8480

1 file changed

Lines changed: 65 additions & 65 deletions

File tree

‎engine/src/test/java/com/arcadedb/schema/LocalSchemaOrphanIndexSelfHealTest.java‎

Lines changed: 65 additions & 65 deletions
Original file line numberDiff line numberDiff line change
@@ -19,19 +19,17 @@
1919
package com.arcadedb.schema;
2020

2121
import com.arcadedb.TestHelper;
22+
import com.arcadedb.log.LogManager;
23+
import com.arcadedb.log.Logger;
2224
import com.arcadedb.serializer.json.JSONObject;
2325
import com.arcadedb.utility.FileUtils;
2426
import org.junit.jupiter.api.Test;
2527

2628
import java.io.File;
27-
import java.io.IOException;
28-
import java.util.ArrayList;
29+
import java.lang.reflect.Field;
2930
import java.util.List;
3031
import java.util.concurrent.CopyOnWriteArrayList;
31-
import java.util.logging.Handler;
3232
import java.util.logging.Level;
33-
import java.util.logging.LogRecord;
34-
import java.util.logging.Logger;
3533

3634
import static org.assertj.core.api.Assertions.assertThat;
3735

@@ -52,7 +50,7 @@
5250
class LocalSchemaOrphanIndexSelfHealTest extends TestHelper {
5351

5452
@Test
55-
void unrelinkableOrphanIndexReferenceIsScrubbedFromSchemaJsonOnLoad() throws IOException {
53+
void unrelinkableOrphanIndexReferenceIsScrubbedFromSchemaJsonOnLoad() throws Exception {
5654
database.transaction(() -> {
5755
final VertexType type = database.getSchema().createVertexType("Widget");
5856
type.createProperty("code", Type.STRING);
@@ -92,39 +90,25 @@ void unrelinkableOrphanIndexReferenceIsScrubbedFromSchemaJsonOnLoad() throws IOE
9290
w.write(schemaJson.toString());
9391
}
9492

95-
// Attach the capturing handler to BOTH the LocalSchema logger and the root logger so we
96-
// receive WARNING records regardless of test-ordering effects on JUL state. Some earlier test
97-
// can leave the LocalSchema logger configured in a way (custom filter, useParentHandlers
98-
// flipped, level overridden) that suppresses the warning at one level; attaching to both the
99-
// origin logger and its common ancestor makes the capture insensitive to that residue.
100-
final CapturingHandler firstHandler = new CapturingHandler();
101-
firstHandler.setLevel(Level.WARNING);
102-
final Logger logger = Logger.getLogger(LocalSchema.class.getName());
103-
final Logger rootLogger = Logger.getLogger("");
104-
logger.addHandler(firstHandler);
105-
rootLogger.addHandler(firstHandler);
106-
final Level prev = logger.getLevel();
107-
logger.setLevel(Level.ALL);
108-
// Also force the parent loggers to ALL so JUL's effective-level check does not filter out
109-
// WARNING records before they reach our handler. The arcadedb-log.properties test config sets
110-
// {@code com.arcadedb.level=SEVERE} which propagates by inheritance to any descendant whose
111-
// own level is null; explicitly overriding com.arcadedb here makes the assertion robust
112-
// against earlier tests that may have reset LocalSchema's level back to null.
113-
final Logger arcadeLogger = Logger.getLogger("com.arcadedb");
114-
final Level prevArcade = arcadeLogger.getLevel();
115-
arcadeLogger.setLevel(Level.ALL);
93+
// Capture warnings by swapping the active LogManager logger for the duration of the test.
94+
// This bypasses JUL entirely, so the assertion does not depend on JUL configuration state
95+
// left over by earlier tests in the same JVM (logger levels, filters, handler chains).
96+
// The pattern mirrors QueryEngineManagerPoolTest.saturationLogsThrottledWarning.
97+
final List<String> warnings = new CopyOnWriteArrayList<>();
98+
final Logger originalLogger = readField(LogManager.instance(), "logger");
99+
LogManager.instance().setLogger(new CapturingLogger(warnings, originalLogger));
116100

117101
try {
118102
// First reopen: the warning fires, but the new self-heal path marks the schema dirty so
119103
// saveConfiguration() rewrites schema.json without the dangling reference.
120104
database = factory.open();
121105

122-
final List<String> firstWarnings = firstHandler.snapshot().stream()
106+
final List<String> firstWarnings = warnings.stream()
123107
.filter(m -> m.contains("Cannot find indexes") || m.contains("Cannot find index"))
124108
.toList();
125109
assertThat(firstWarnings)
126110
.as("first load must surface the 'Cannot find indexes' warning so the operator notices the divergence (captured=%s)",
127-
firstHandler.snapshot())
111+
warnings)
128112
.isNotEmpty();
129113

130114
// The on-disk schema must no longer contain the dangling reference - that is the whole
@@ -139,29 +123,18 @@ void unrelinkableOrphanIndexReferenceIsScrubbedFromSchemaJsonOnLoad() throws IOE
139123
.as("the dangling index reference must be scrubbed from schema.json after the warning fires")
140124
.isFalse();
141125

142-
// Second reopen with a fresh handler: the dangling reference is gone, so no warning at all.
143-
logger.removeHandler(firstHandler);
144-
rootLogger.removeHandler(firstHandler);
145-
final CapturingHandler secondHandler = new CapturingHandler();
146-
secondHandler.setLevel(Level.WARNING);
147-
logger.addHandler(secondHandler);
148-
rootLogger.addHandler(secondHandler);
149-
try {
150-
database = factory.open();
151-
152-
final List<String> secondWarnings = secondHandler.snapshot().stream()
153-
.filter(m -> m.contains("Cannot find indexes") || m.contains("Cannot find index"))
154-
.toList();
155-
assertThat(secondWarnings)
156-
.as("second load must NOT repeat the warning - the self-heal pass already removed the dangling reference")
157-
.isEmpty();
158-
} finally {
159-
logger.removeHandler(secondHandler);
160-
rootLogger.removeHandler(secondHandler);
161-
}
126+
// Second reopen: the dangling reference is gone, so no warning at all.
127+
warnings.clear();
128+
database = factory.open();
129+
130+
final List<String> secondWarnings = warnings.stream()
131+
.filter(m -> m.contains("Cannot find indexes") || m.contains("Cannot find index"))
132+
.toList();
133+
assertThat(secondWarnings)
134+
.as("second load must NOT repeat the warning - the self-heal pass already removed the dangling reference")
135+
.isEmpty();
162136
} finally {
163-
logger.setLevel(prev);
164-
arcadeLogger.setLevel(prevArcade);
137+
LogManager.instance().setLogger(originalLogger);
165138
}
166139
}
167140

@@ -170,34 +143,61 @@ protected String getDatabasePath() {
170143
return "target/databases/LocalSchemaOrphanIndexSelfHealTest";
171144
}
172145

173-
private static final class CapturingHandler extends Handler {
174-
private final List<String> records = new CopyOnWriteArrayList<>();
146+
@SuppressWarnings("unchecked")
147+
private static <T> T readField(final Object target, final String name) throws Exception {
148+
final Field f = target.getClass().getDeclaredField(name);
149+
f.setAccessible(true);
150+
return (T) f.get(target);
151+
}
152+
153+
/**
154+
* Captures WARNING-and-above messages into a list while forwarding every record to the
155+
* production logger so the test output still shows what fired.
156+
*/
157+
private static final class CapturingLogger implements Logger {
158+
private final List<String> warnings;
159+
private final Logger delegate;
160+
161+
CapturingLogger(final List<String> warnings, final Logger delegate) {
162+
this.warnings = warnings;
163+
this.delegate = delegate;
164+
}
175165

176-
@Override
177-
public void publish(final LogRecord record) {
178-
if (record == null || record.getLevel().intValue() < Level.WARNING.intValue())
166+
private void capture(final Level level, final String message, final Object... args) {
167+
if (message == null || level.intValue() < Level.WARNING.intValue())
179168
return;
180-
String msg = record.getMessage();
181-
if (msg != null && record.getParameters() != null && record.getParameters().length > 0) {
169+
String formatted = message;
170+
if (args != null && args.length > 0) {
182171
try {
183-
msg = msg.formatted(record.getParameters());
172+
formatted = message.formatted(args);
184173
} catch (final Exception ignored) {
174+
// Fall back to the raw template - good enough for our substring matching below.
185175
}
186176
}
187-
if (msg != null)
188-
records.add(msg);
177+
warnings.add(formatted);
189178
}
190179

191180
@Override
192-
public void flush() {
181+
public void log(final Object requester, final Level level, final String message, final Throwable exception,
182+
final String context, final Object arg1, final Object arg2, final Object arg3, final Object arg4, final Object arg5,
183+
final Object arg6, final Object arg7, final Object arg8, final Object arg9, final Object arg10, final Object arg11,
184+
final Object arg12, final Object arg13, final Object arg14, final Object arg15, final Object arg16, final Object arg17) {
185+
capture(level, message, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15,
186+
arg16, arg17);
187+
delegate.log(requester, level, message, exception, context, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10,
188+
arg11, arg12, arg13, arg14, arg15, arg16, arg17);
193189
}
194190

195191
@Override
196-
public void close() throws SecurityException {
192+
public void log(final Object requester, final Level level, final String message, final Throwable exception,
193+
final String context, final Object... args) {
194+
capture(level, message, args);
195+
delegate.log(requester, level, message, exception, context, args);
197196
}
198197

199-
List<String> snapshot() {
200-
return new ArrayList<>(records);
198+
@Override
199+
public void flush() {
200+
delegate.flush();
201201
}
202202
}
203203
}

0 commit comments

Comments
 (0)