1919package com .arcadedb .schema ;
2020
2121import com .arcadedb .TestHelper ;
22+ import com .arcadedb .log .LogManager ;
23+ import com .arcadedb .log .Logger ;
2224import com .arcadedb .serializer .json .JSONObject ;
2325import com .arcadedb .utility .FileUtils ;
2426import org .junit .jupiter .api .Test ;
2527
2628import java .io .File ;
27- import java .io .IOException ;
28- import java .util .ArrayList ;
29+ import java .lang .reflect .Field ;
2930import java .util .List ;
3031import java .util .concurrent .CopyOnWriteArrayList ;
31- import java .util .logging .Handler ;
3232import java .util .logging .Level ;
33- import java .util .logging .LogRecord ;
34- import java .util .logging .Logger ;
3533
3634import static org .assertj .core .api .Assertions .assertThat ;
3735
5250class 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