[UNTESTED] Fixes notifiers and adds some additional methods. Adds tests.

Changes: // ArcaneEnvironment breaking: context.read<ArcaneEnvironment>() -> ArcaneEnvironment.of(context) breaking: context.read<ArcaneEnvironment>().state -> ArcaneEnvironment.of(context).environment; // Feature flag service added: reset() // Logging service added: registerInterface() added: unregisterInterfaces() added: unregisterAllInterfaces() // ArcaneReactiveTheme fixed: currentMode, dark, light now actually emit new values when changed added: getters for lightTheme, darkTheme, and systemTheme TODO: test systemTheme Signed-off-by: Hans Kokx <hans.d.kokx@gmail.com>
2026-05-14 10:29:06 +02:00 · 2025-04-04 17:08:06 +02:00
parent b129639f1f
commit ac82e93b9d
16 changed files with 1233 additions and 89 deletions
@@ -0,0 +1,203 @@
+import "package:arcane_framework/arcane_framework.dart";
+import "package:flutter_test/flutter_test.dart";
+import "package:mockito/annotations.dart";
+import "package:mockito/mockito.dart";
+
+import "logging_service_test.mocks.dart";
+
+class MyOtherLoggingInterface extends Mock implements MockLoggingInterface {}
+
+@GenerateNiceMocks([
+  MockSpec<LoggingInterface>(
+    onMissingStub: OnMissingStub.returnDefault,
+  ),
+])
+void main() {
+  final LoggingInterface myInterface = MockLoggingInterface();
+
+  setUp(() {
+    Arcane.logger.reset();
+  });
+
+  group("ArcaneLogger", () {
+    group("interface management", () {
+      test("registerInterfaces adds interfaces correctly", () async {
+        await Arcane.logger.registerInterface(myInterface);
+
+        expect(
+          Arcane.logger.interfaces,
+          contains(isA<LoggingInterface>()),
+        );
+      });
+
+      test("registering an interface doesn't initialize it", () async {
+        await Arcane.logger.registerInterface(myInterface);
+
+        expect(Arcane.logger.interfaces.first, isA<LoggingInterface>());
+
+        expect(myInterface.initialized, false);
+        verifyNever(myInterface.init());
+      });
+
+      test("registering an interface initializes the logger", () async {
+        expect(Arcane.logger.initialized, false);
+
+        await Arcane.logger.registerInterface(myInterface);
+
+        expect(Arcane.logger.initialized, true);
+      });
+
+      test("interfaces can be initialized through the logger", () async {
+        await Arcane.logger.registerInterface(myInterface);
+
+        expect(Arcane.logger.interfaces.first.initialized, false);
+
+        await Arcane.logger.initializeInterfaces();
+
+        verify(Arcane.logger.interfaces.first.init()).called(1);
+      });
+
+      test("multiple interfaces can be registered", () async {
+        await Arcane.logger.registerInterfaces([
+          MockLoggingInterface(),
+          MyOtherLoggingInterface(),
+        ]);
+
+        expect(
+          Arcane.logger.interfaces,
+          contains(isA<MockLoggingInterface>()),
+        );
+        expect(
+          Arcane.logger.interfaces,
+          contains(isA<MyOtherLoggingInterface>()),
+        );
+      });
+    });
+
+    group("persistent metadata", () {
+      test("addPersistentMetadata adds metadata correctly", () {
+        Arcane.logger.addPersistentMetadata({"test": "value"});
+        expect(Arcane.logger.additionalMetadata["test"], equals("value"));
+      });
+
+      test("removePersistentMetadata removes specific key", () {
+        Arcane.logger.addPersistentMetadata({"test": "value", "keep": "this"});
+        Arcane.logger.removePersistentMetadata("test");
+        expect(Arcane.logger.additionalMetadata.containsKey("test"), false);
+        expect(Arcane.logger.additionalMetadata["keep"], equals("this"));
+      });
+
+      test("clearPersistentMetadata removes all metadata", () {
+        Arcane.logger
+            .addPersistentMetadata({"test": "value", "another": "value"});
+        Arcane.logger.clearPersistentMetadata();
+        expect(Arcane.logger.additionalMetadata.isEmpty, true);
+      });
+    });
+
+    group("logging messages", () {
+      const String logMessage = "Test";
+
+      setUp(() async {
+        await Arcane.logger.registerInterface(myInterface);
+      });
+
+      test("logging a basic message works", () async {
+        Arcane.log(logMessage);
+
+        verify(
+          myInterface.log(
+            logMessage,
+            metadata: anyNamed("metadata"),
+            level: anyNamed("level"),
+            stackTrace: anyNamed("stackTrace"),
+            extra: anyNamed("extra"),
+          ),
+        ).called(1);
+      });
+
+      test("logging at a different level works", () async {
+        Arcane.log(
+          logMessage,
+          level: Level.info,
+        );
+
+        verify(
+          myInterface.log(
+            logMessage,
+            metadata: anyNamed("metadata"),
+            level: Level.info,
+            stackTrace: anyNamed("stackTrace"),
+            extra: anyNamed("extra"),
+          ),
+        ).called(1);
+
+        Arcane.log(
+          logMessage,
+          level: Level.warning,
+        );
+
+        verify(
+          myInterface.log(
+            logMessage,
+            metadata: anyNamed("metadata"),
+            level: Level.warning,
+            stackTrace: anyNamed("stackTrace"),
+            extra: anyNamed("extra"),
+          ),
+        ).called(1);
+      });
+
+      test("logging a stacktrace works", () async {
+        final stackTrace = StackTrace.current;
+        Arcane.log(logMessage, stackTrace: stackTrace);
+
+        verify(
+          myInterface.log(
+            logMessage,
+            metadata: anyNamed("metadata"),
+            level: anyNamed("level"),
+            stackTrace: stackTrace,
+            extra: anyNamed("extra"),
+          ),
+        ).called(1);
+      });
+
+      test("logging an extra object works", () async {
+        const bool extraObject = true;
+        Arcane.log(
+          logMessage,
+          extra: extraObject,
+        );
+
+        verify(
+          myInterface.log(
+            logMessage,
+            metadata: anyNamed("metadata"),
+            level: anyNamed("level"),
+            stackTrace: anyNamed("stackTrace"),
+            extra: extraObject,
+          ),
+        ).called(1);
+      });
+
+      test("logging metadata works", () async {
+        final Map<String, String> metadata = {"test": "value"};
+        Arcane.log(
+          logMessage,
+          metadata: metadata,
+        );
+
+        verify(
+          myInterface.log(
+            logMessage,
+            metadata: metadata,
+            level: anyNamed("level"),
+            stackTrace: anyNamed("stackTrace"),
+            extra: anyNamed("extra"),
+          ),
+        ).called(1);
+      });
+    });
+  });
+}