feat(policy_manager): enhance policy initialization with validation and logging

Author: dgarciasquare1

lib/src/core/policy_manager.dart

@@ -253,7 +253,113 @@ class PolicyManager extends ChangeNotifier {
     try {
       final assetHandler = ExternalAssetHandler(assetPath: assetPath);
       final jsonPolicies = await assetHandler.loadAssets();
-      await initialize(jsonPolicies);
+
+      try {
+        LogHandler.info(
+          'Initializing policy manager with assets',
+          context: {
+            'policy_count': jsonPolicies.length,
+            'policy_keys': jsonPolicies.keys.take(5).toList(),
+          },
+          operation: 'policy_manager_initialize',
+        );
+
+        // Create a map of valid policies, skipping invalid ones
+        final validPolicies = <String, Map<String, dynamic>>{};
+
+        for (final entry in jsonPolicies.entries) {
+          final key = entry.key;
+          final value = entry.value;
+
+          if (value == null) {
+            LogHandler.warning(
+              'Skipping null policy value',
+              context: {'role': key},
+              operation: 'policy_validation_skip',
+            );
+            continue;
+          }
+
+          if (value is! Map<String, dynamic>) {
+            LogHandler.warning(
+              'Skipping invalid policy value type',
+              context: {
+                'role': key,
+                'expected_type': 'Map<String, dynamic>',
+                'actual_type': value.runtimeType.toString(),
+              },
+              operation: 'policy_validation_skip',
+            );
+            continue;
+          }
+
+          // Add key as role name to value if not already present
+          if (!value.containsKey('roleName')) {
+            value['roleName'] = key;
+          }
+
+          try {
+            // Create the policy and add to valid policies
+            final role = Role.fromJson(value);
+            validPolicies[key] = role.toJson();
+          } catch (e) {
+            LogHandler.warning(
+              'Skipping policy with invalid structure',
+              context: {'role': key, 'error': e.toString()},
+              operation: 'policy_validation_skip',
+            );
+            continue;
+          }
+        }
+
+        _roles = JsonHandler.parseMap(
+          validPolicies,
+          (json) => Role.fromJson(json),
+          context: 'policy_manager',
+          allowPartialSuccess: true,
+        );
+
+        // Only create evaluator if we have at least some policies
+        if (_roles.isNotEmpty) {
+          _evaluator = RoleEvaluator(_roles);
+          await _storage.savePolicies(_roles);
+          _isInitialized = true;
+
+          LogHandler.info(
+            'Policy manager initialized successfully',
+            context: {
+              'loaded_policies': _roles.length,
+              'total_policies': jsonPolicies.length,
+            },
+            operation: 'policy_manager_initialized',
+          );
+        } else {
+          LogHandler.warning(
+            'Policy manager initialized with no valid policies',
+            context: {
+              'total_policies': jsonPolicies.length,
+            },
+            operation: 'policy_manager_empty',
+          );
+          // Still mark as initialized but with empty policies
+          _isInitialized = true;
+        }
+
+        notifyListeners();
+      } catch (e, stackTrace) {
+        LogHandler.error(
+          'Failed to initialize policy manager',
+          error: e,
+          stackTrace: stackTrace,
+          context: {
+            'policy_count': jsonPolicies.length,
+          },
+          operation: 'policy_manager_initialize_error',
+        );
+
+        // Re-throw to allow caller to handle the error
+        rethrow;
+      }
     } catch (e, stackTrace) {
       LogHandler.error(
         'Failed to initialize policy manager from JSON assets',

test/core/policy_manager_test.dart

@@ -457,8 +457,12 @@ void main() {
         // Mock the rootBundle to return valid JSON
         const validJson = '''
         {
-          "admin": ["read", "write", "delete"],
-          "user": ["read"]
+          "admin": {
+            "allowedContent": ["read", "write", "delete"]
+          },
+          "user": {
+            "allowedContent": ["read"]
+          }
         }
         ''';
 
@@ -471,6 +475,7 @@ void main() {
         await policyManager
             .initializeFromJsonAssets('assets/policies/test.json');
 
+        // The method should initialize successfully with valid JSON
         expect(policyManager.isInitialized, isTrue);
         expect(policyManager.roles.length, equals(2));
         expect(policyManager.roles['admin'], isA<Role>());
@@ -528,9 +533,16 @@ void main() {
         // Mock the rootBundle to return JSON with malformed policy data
         const malformedJson = '''
         {
-          "admin": "not_a_list",
+          "admin": {
+            "allowedContent": "not_a_list"
+          },
           "user": null,
-          "guest": ["read"]
+          "guest": {
+            "allowedContent": ["read"]
+          },
+          "invalid_role": {
+            "allowedContent": [123, "read"]
+          }
         }
         ''';
 
@@ -547,8 +559,11 @@ void main() {
         expect(policyManager.isInitialized, isTrue);
         expect(policyManager.roles.length, equals(1));
         expect(policyManager.roles['guest'], isNotNull);
+        expect(policyManager.roles['guest']!.name, equals('guest'));
+        expect(policyManager.roles['guest']!.allowedContent, contains('read'));
         expect(policyManager.roles['admin'], isNull);
         expect(policyManager.roles['user'], isNull);
+        expect(policyManager.roles['invalid_role'], isNull);
 
         // Clean up mock message handler
         TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger
@@ -580,7 +595,9 @@ void main() {
         // Mock the rootBundle to return JSON with single policy
         const singlePolicyJson = '''
         {
-          "admin": ["read", "write"]
+          "admin": {
+            "allowedContent": ["read", "write"]
+          }
         }
         ''';
 
@@ -608,7 +625,9 @@ void main() {
         // Create a large JSON with many policies
         final largeJson = <String, dynamic>{};
         for (int i = 0; i < 100; i++) {
-          largeJson['role_$i'] = ['read', 'write'];
+          largeJson['role_$i'] = {
+            'allowedContent': ['read', 'write']
+          };
         }
 
         TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger
@@ -632,8 +651,12 @@ void main() {
         // Mock the rootBundle to return JSON with empty content arrays
         const emptyContentJson = '''
         {
-          "admin": [],
-          "user": ["read"]
+          "admin": {
+            "allowedContent": []
+          },
+          "user": {
+            "allowedContent": ["read"]
+          }
         }
         ''';
 
@@ -661,7 +684,9 @@ void main() {
         // Mock the rootBundle to return JSON with duplicate content
         const duplicateContentJson = '''
         {
-          "admin": ["read", "read", "write", "write"]
+          "admin": {
+            "allowedContent": ["read", "read", "write", "write"]
+          }
         }
         ''';
 
@@ -698,8 +723,12 @@ void main() {
         // Mock the rootBundle to return valid JSON
         const validJson = '''
         {
-          "admin": ["read", "write"],
-          "user": ["read"]
+          "admin": {
+            "allowedContent": ["read", "write"]
+          },
+          "user": {
+            "allowedContent": ["read"]
+          }
         }
         ''';
 
@@ -732,7 +761,9 @@ void main() {
         // Mock the rootBundle to return valid JSON
         const validJson = '''
         {
-          "admin": ["read", "write"]
+          "admin": {
+            "allowedContent": ["read", "write"]
+          }
         }
         ''';
 
@@ -772,7 +803,9 @@ void main() {
         // Mock the rootBundle to return valid JSON
         const validJson = '''
         {
-          "admin": ["read", "write"]
+          "admin": {
+            "allowedContent": ["read", "write"]
+          }
         }
         ''';
 
@@ -786,6 +819,7 @@ void main() {
             .initializeFromJsonAssets('assets/policies/test.json');
 
         // Check that the expected policy is present in storage
+        expect(freshPolicyManager.isInitialized, isTrue);
         expect(freshStorage.storedPolicies['admin'], isA<Role>());
         expect(
           (freshStorage.storedPolicies['admin'] as Role).allowedContent,
@@ -805,7 +839,9 @@ void main() {
         // Mock the rootBundle to return valid JSON
         const validJson = '''
         {
-          "admin": ["read", "write"]
+          "admin": {
+            "allowedContent": ["read", "write"]
+          }
         }
         ''';