Fix lint errors: rename functions and variables to follow snake_case convention

- Rename test functions from camelCase to snake_case:
  - test_create_user_from_context_with_userId → test_create_user_from_context_with_user_id_attribute
  - test_create_user_from_context_userId_excluded_when_used → test_create_user_from_context_user_id_attr_excluded_when_used
  - test_create_user_from_context_invalid_userId_types → test_create_user_from_context_invalid_user_id_attr_types
  - test_resolve_details_with_userId_priority → test_resolve_details_with_user_id_attr_priority

- Rename variables from camelCase to snake_case:
  - userId → user_id_attr (to avoid confusion with user_id)

- Remove unused variable assignments in test_provider.py
- Fix whitespace and trailing whitespace issues

Author: jonathannorris

devcycle_python_sdk/models/user.py

@@ -124,7 +124,7 @@ def create_user_from_context(
             raise TargetingKeyMissingError(
                 "DevCycle: Evaluation context does not contain a valid targeting key, user_id, or userId attribute"
             )
-        
+
         if not isinstance(user_id, str):
             raise TargetingKeyMissingError(
                 f"DevCycle: {user_id_source} must be a string, got {type(user_id).__name__}"

test/models/test_user.py

@@ -53,70 +53,70 @@ def test_create_user_from_context_only_user_id(self):
         self.assertIsNotNone(user)
         self.assertEqual(user.user_id, test_user_id)
 
-    def test_create_user_from_context_with_userId(self):
+    def test_create_user_from_context_with_user_id_attribute(self):
         test_user_id = "userId-12345"
-        
+
         # Test userId as the only user ID source
         context = EvaluationContext(
             targeting_key=None, attributes={"userId": test_user_id}
         )
         user = DevCycleUser.create_user_from_context(context)
         self.assertIsNotNone(user)
         self.assertEqual(user.user_id, test_user_id)
-        
+
         # Test that userId is excluded from custom data when used as user ID
         self.assertIsNone(user.customData)
 
     def test_create_user_from_context_user_id_priority(self):
         targeting_key_id = "targeting-12345"
         user_id = "user_id-12345"
-        userId = "userId-12345"
-        
+        user_id_attr = "userId-12345"
+
         # Test targeting_key takes precedence over user_id and userId
         context = EvaluationContext(
-            targeting_key=targeting_key_id, 
-            attributes={"user_id": user_id, "userId": userId}
+            targeting_key=targeting_key_id,
+            attributes={"user_id": user_id, "userId": user_id_attr}
         )
         user = DevCycleUser.create_user_from_context(context)
         self.assertEqual(user.user_id, targeting_key_id)
-        
+
         # Test user_id takes precedence over userId
         context = EvaluationContext(
-            targeting_key=None, 
-            attributes={"user_id": user_id, "userId": userId}
+            targeting_key=None,
+            attributes={"user_id": user_id, "userId": user_id_attr}
         )
         user = DevCycleUser.create_user_from_context(context)
         self.assertEqual(user.user_id, user_id)
-        
+
         # Test userId is used when targeting_key and user_id are not available
         context = EvaluationContext(
-            targeting_key=None, 
-            attributes={"userId": userId}
+            targeting_key=None,
+            attributes={"userId": user_id_attr}
         )
         user = DevCycleUser.create_user_from_context(context)
-        self.assertEqual(user.user_id, userId)
+        self.assertEqual(user.user_id, user_id_attr)
 
     def test_create_user_from_context_user_id_fields_always_excluded(self):
         targeting_key_id = "targeting-12345"
-        userId = "userId-12345"
+        user_id_attr = "userId-12345"
         user_id = "user_id-12345"
-        
+
         # When targeting_key is used, both user_id and userId should be excluded from custom data
         context = EvaluationContext(
-            targeting_key=targeting_key_id, 
-            attributes={"user_id": user_id, "userId": userId, "other_field": "value"}
+            targeting_key=targeting_key_id,
+            attributes={"user_id": user_id, "userId": user_id_attr, "other_field": "value"}
         )
         user = DevCycleUser.create_user_from_context(context)
         self.assertEqual(user.user_id, targeting_key_id)
         self.assertIsNotNone(user.customData)
         self.assertNotIn("user_id", user.customData)
         self.assertNotIn("userId", user.customData)
         self.assertEqual(user.customData["other_field"], "value")
-        
+
         # When user_id is used, userId should still be excluded from custom data
         context = EvaluationContext(
-            targeting_key=None, 
-            attributes={"user_id": user_id, "userId": userId, "other_field": "value"}
+            targeting_key=None,
+            attributes={"user_id": user_id, "userId": user_id_attr, "other_field": "value"}
         )
         user = DevCycleUser.create_user_from_context(context)
         self.assertEqual(user.user_id, user_id)
@@ -127,10 +127,10 @@ def test_create_user_from_context_user_id_fields_always_excluded(self):
 
     def test_create_user_from_context_targeting_key_excluded_from_attributes(self):
         targeting_key_id = "targeting-12345"
-        
+
         # When targeting_key appears in attributes, it should be excluded from custom data
         context = EvaluationContext(
-            targeting_key=targeting_key_id, 
+            targeting_key=targeting_key_id,
             attributes={"targeting_key": "should-be-excluded", "other_field": "value"}
         )
         user = DevCycleUser.create_user_from_context(context)
@@ -139,32 +139,32 @@ def test_create_user_from_context_targeting_key_excluded_from_attributes(self):
         self.assertNotIn("targeting_key", user.customData)
         self.assertEqual(user.customData["other_field"], "value")
 
-    def test_create_user_from_context_userId_excluded_when_used(self):
-        userId = "userId-12345"
-        
+    def test_create_user_from_context_user_id_attr_excluded_when_used(self):
+        user_id_attr = "userId-12345"
+
         # When userId is used as user ID, it should be excluded from custom data
         context = EvaluationContext(
-            targeting_key=None, 
-            attributes={"userId": userId, "other_field": "value"}
+            targeting_key=None,
+            attributes={"userId": user_id_attr, "other_field": "value"}
         )
         user = DevCycleUser.create_user_from_context(context)
-        self.assertEqual(user.user_id, userId)
+        self.assertEqual(user.user_id, user_id_attr)
         self.assertIsNotNone(user.customData)
         self.assertNotIn("userId", user.customData)
         self.assertEqual(user.customData["other_field"], "value")
 
-    def test_create_user_from_context_invalid_userId_types(self):
+    def test_create_user_from_context_invalid_user_id_attr_types(self):
         # Test non-string userId values are ignored and cause error
         with self.assertRaises(TargetingKeyMissingError):
             DevCycleUser.create_user_from_context(
                 EvaluationContext(targeting_key=None, attributes={"userId": 12345})
             )
-            
+
         with self.assertRaises(TargetingKeyMissingError):
             DevCycleUser.create_user_from_context(
                 EvaluationContext(targeting_key=None, attributes={"userId": None})
             )
-            
+
         with self.assertRaises(TargetingKeyMissingError):
             DevCycleUser.create_user_from_context(
                 EvaluationContext(targeting_key=None, attributes={"userId": True})

test/openfeature_test/test_provider.py

@@ -214,7 +214,7 @@ def test_resolve_object_details(self):
         self.assertDictEqual(details.value, variable_value)
         self.assertEqual(details.reason, Reason.TARGETING_MATCH)
 
-    def test_resolve_details_with_userId_priority(self):
+    def test_resolve_details_with_user_id_attr_priority(self):
         """Test that userId is used with proper priority: targeting_key > user_id > userId"""
         key = "test-flag"
         default_value = False
@@ -228,30 +228,30 @@ def test_resolve_details_with_userId_priority(self):
             targeting_key="targeting-key-user",
             attributes={"user_id": "user_id-user", "userId": "userId-user"}
         )
-        details = self.provider.resolve_boolean_details(key, default_value, context)
-        
+        self.provider.resolve_boolean_details(key, default_value, context)
+
         # Verify the call was made with the right user
         self.client.variable.assert_called()
         called_user = self.client.variable.call_args[1]['user']
         self.assertEqual(called_user.user_id, "targeting-key-user")
-        
+
         # Test 2: user_id takes precedence over userId when no targeting_key
         context = EvaluationContext(
             targeting_key=None,
             attributes={"user_id": "user_id-user", "userId": "userId-user"}
         )
-        details = self.provider.resolve_boolean_details(key, default_value, context)
-        
+        self.provider.resolve_boolean_details(key, default_value, context)
+
         called_user = self.client.variable.call_args[1]['user']
         self.assertEqual(called_user.user_id, "user_id-user")
-        
+
         # Test 3: userId is used when no targeting_key or user_id
         context = EvaluationContext(
             targeting_key=None,
             attributes={"userId": "userId-user"}
         )
-        details = self.provider.resolve_boolean_details(key, default_value, context)
-        
+        self.provider.resolve_boolean_details(key, default_value, context)
+
         called_user = self.client.variable.call_args[1]['user']
         self.assertEqual(called_user.user_id, "userId-user")