Update service provider

Signed-off-by: Hans Kokx <hans.d.kokx@gmail.com>

test/providers/service_provider_test.dart

@@ -20,7 +20,7 @@ void main() {
           child: Builder(
             builder: (context) {
               final provider = ArcaneServiceProvider.of(context);
-              expect(provider?.serviceInstances, equals(testServices));
+              expect(provider.serviceInstances, equals(testServices));
               return const SizedBox();
             },
           ),
@@ -28,13 +28,122 @@ void main() {
       );
     });
 
-    testWidgets("serviceOfType extension returns correct service",
+    testWidgets("static serviceOfType<T> method returns correct service",
         (tester) async {
       await tester.pumpWidget(
         ArcaneApp(
           services: testServices,
           child: Builder(
             builder: (context) {
+              final service =
+                  ArcaneServiceProvider.serviceOfType<MockArcaneService>(
+                context,
+              );
+              expect(service, isNotNull);
+              expect(service, isA<MockArcaneService>());
+              return const SizedBox();
+            },
+          ),
+        ),
+      );
+    });
+
+    testWidgets(
+        "static serviceOfType<T> method returns correct service and returns null when not found",
+        (tester) async {
+      await tester.pumpWidget(
+        ArcaneApp(
+          services: testServices,
+          child: Builder(
+            builder: (context) {
+              // Should find this service
+              final service =
+                  ArcaneServiceProvider.serviceOfType<MockArcaneService>(
+                context,
+              );
+
+              expect(service, isA<MockArcaneService>());
+
+              // Returns null for unregistered services
+              expect(
+                ArcaneServiceProvider.serviceOfType<UnregisteredService>(
+                  context,
+                ),
+                isNull,
+              );
+
+              return const SizedBox();
+            },
+          ),
+        ),
+      );
+    });
+
+    testWidgets("service<T> extension returns correct service", (tester) async {
+      await tester.pumpWidget(
+        ArcaneApp(
+          services: testServices,
+          child: Builder(
+            builder: (context) {
+              final service = context.service<MockArcaneService>();
+              expect(service, isNotNull);
+              expect(service, isA<MockArcaneService>());
+              return const SizedBox();
+            },
+          ),
+        ),
+      );
+    });
+
+    testWidgets(
+        "requiredService<T> extension returns correct service and throws when not found",
+        (tester) async {
+      await tester.pumpWidget(
+        ArcaneApp(
+          services: testServices,
+          child: Builder(
+            builder: (context) {
+              // Should find this service
+              final service = context.requiredService<MockArcaneService>();
+              expect(service, isA<MockArcaneService>());
+
+              // Should throw for missing service
+              expect(
+                () => context.requiredService<UnregisteredService>(),
+                throwsA(isA<AssertionError>()),
+              );
+
+              return const SizedBox();
+            },
+          ),
+        ),
+      );
+    });
+
+    testWidgets("service<T> returns null for unregistered service",
+        (tester) async {
+      await tester.pumpWidget(
+        ArcaneApp(
+          services: testServices,
+          child: Builder(
+            builder: (context) {
+              final service = context.service<UnregisteredService>();
+              expect(service, isNull);
+              return const SizedBox();
+            },
+          ),
+        ),
+      );
+    });
+
+    testWidgets("legacy serviceOfType method still works but is deprecated",
+        (tester) async {
+      await tester.pumpWidget(
+        ArcaneApp(
+          services: testServices,
+          child: Builder(
+            builder: (context) {
+              // ignore: deprecated_member_use_from_same_package
               final service = context.serviceOfType<MockArcaneService>();
               expect(service, isNotNull);
               expect(service, isA<MockArcaneService>());
@@ -45,15 +154,49 @@ void main() {
       );
     });
 
-    testWidgets("serviceOfType returns null for unregistered service",
-        (tester) async {
+    testWidgets("service updates trigger rebuilds", (tester) async {
+      late ArcaneServiceProvider provider;
+      int buildCount = 0;
+
+      await tester.pumpWidget(
+        MaterialApp(
+          home: ArcaneServiceProvider(
+            serviceInstances: testServices,
+            child: Builder(
+              builder: (context) {
+                provider = ArcaneServiceProvider.of(context);
+                buildCount++;
+                // Access a service to create dependency
+                context.service<MockArcaneService>();
+                return const Text("Test");
+              },
+            ),
+          ),
+        ),
+      );
+
+      expect(buildCount, 1);
+
+      // Update services and verify rebuild
+      provider.setServices([MockArcaneService(), AnotherMockService()]);
+      await tester.pump();
+      expect(buildCount, 2);
+
+      // Add a service and verify rebuild
+      provider.addService(UnregisteredService());
+      await tester.pump();
+      expect(buildCount, 3);
+    });
+
+    testWidgets("ArcaneService.of<T> static helper works", (tester) async {
       await tester.pumpWidget(
         ArcaneApp(
           services: testServices,
           child: Builder(
             builder: (context) {
-              final service = context.serviceOfType<UnregisteredService>();
-              expect(service, isNull);
+              final service = ArcaneService.of<MockArcaneService>(context);
+              expect(service, isNotNull);
+              expect(service, isA<MockArcaneService>());
               return const SizedBox();
             },
           ),
@@ -61,25 +204,32 @@ void main() {
       );
     });
 
-    testWidgets("updateShouldNotify always returns true", (tester) async {
-      final provider = ArcaneServiceProvider(
-        serviceInstances: testServices,
-        child: const SizedBox(),
-      );
+    testWidgets("ArcaneService.requiredOf<T> static helper works",
+        (tester) async {
+      await tester.pumpWidget(
+        ArcaneApp(
+          services: testServices,
+          child: Builder(
+            builder: (context) {
+              final service =
+                  ArcaneService.requiredOf<MockArcaneService>(context);
+              expect(service, isA<MockArcaneService>());
 
-      expect(
-        provider.updateShouldNotify(
-          ArcaneServiceProvider(
-            serviceInstances: testServices,
-            child: const SizedBox(),
+              expect(
+                () => ArcaneService.requiredOf<UnregisteredService>(context),
+                throwsA(isA<AssertionError>()),
+              );
+
+              return const SizedBox();
+            },
           ),
         ),
-        true,
       );
     });
   });
 }
 
+// Mock classes for testing
 class MockArcaneService extends ArcaneService {}
 
 class AnotherMockService extends ArcaneService {}