fix: Refactor Quix Config Lookup version selection and add comprehensive tests

- Refactor Configuration.find_valid_version and _find_versions to handle edge cases
- Add tests the quix configuration service lookup

Author: ovv

quixstreams/dataframe/joins/lookups/quix_configuration_service/models.py

@@ -238,33 +238,52 @@ def find_valid_version(self, timestamp: int) -> Optional[ConfigurationVersion]:
 
         :returns: Optional[ConfigurationVersion]: The valid version, or None if not found.
         """
+        # No versions exist
         if not self.versions:
             return None
+
+        # If no version is cached yet, find and cache the versions for this timestamp
         if self.version is None:
             self.previous_version, self.version, self.next_version = (
                 self._find_versions(timestamp)
             )
             return self.version
-        if (
-            self.next_version
-            and self.next_version.valid_from
-            and self.next_version.valid_from <= timestamp
-        ):
-            self.previous_version, self.version, self.next_version = (
-                self._find_versions(timestamp)
-            )
-            return self.version
-        if self.version:
-            if self.version.valid_from is None:
+
+        # Check if the next version has become valid (timestamp has moved forward)
+        # If so, recalculate all cached versions
+        if self.next_version:
+            # If next version has no valid_from date, it's always valid
+            if self.next_version.valid_from is None:
+                self.previous_version, self.version, self.next_version = (
+                    self._find_versions(timestamp)
+                )
                 return self.version
-            if self.version.valid_from <= timestamp:
+            # If next version's valid_from is before or at the timestamp, it's valid
+            if self.next_version.valid_from <= timestamp:
+                self.previous_version, self.version, self.next_version = (
+                    self._find_versions(timestamp)
+                )
                 return self.version
+
+        # Check if the current cached version is still valid for this timestamp
+        # If version has no valid_from date, it's always valid
+        if self.version.valid_from is None:
+            return self.version
+        # If version's valid_from is before or at the timestamp, it's valid
+        if self.version.valid_from <= timestamp:
+            return self.version
+
+        # Fallback: check if the previous version is valid for this timestamp
+        # This can happen when messages are out of order and timestamp is before the current version's valid_from
         if self.previous_version:
+            # If previous version has no valid_from date, it's always valid
             if self.previous_version.valid_from is None:
                 return self.previous_version
+            # If previous version's valid_from is before or at the timestamp, it's valid
             if self.previous_version.valid_from <= timestamp:
                 return self.previous_version
 
+        # If cached versions don't match, recalculate all versions for this timestamp
         self.previous_version, self.version, self.next_version = self._find_versions(
             timestamp
         )
@@ -293,27 +312,45 @@ def _find_versions(
         current_version: Optional[ConfigurationVersion] = None
         next_version: Optional[ConfigurationVersion] = None
 
+        # Iterate through versions in descending order (highest version number first)
+        # This ensures we process the most recent versions first
         for _, version in sorted(
             self.versions.items(), reverse=True, key=lambda x: x[0]
         ):
+            # Handle versions with no valid_from timestamp (always valid)
             if version.valid_from is None:
+                # First version with no valid_from becomes the current version
                 if current_version is None:
                     current_version = version
+                    return previous_version, current_version, next_version
+                # Second version with no valid_from becomes the previous version
                 elif previous_version is None:
                     previous_version = version
+                    # Early return since we have current and previous, no next needed for no-timestamp versions
                     return previous_version, current_version, next_version
+
+            # Handle versions that are valid in the future (after the timestamp)
             elif version.valid_from > timestamp:
+                # First future version becomes the next version
                 if next_version is None:
                     next_version = version
+                # If we find an earlier future version, it becomes the new next version
                 elif (
                     next_version.valid_from is not None
                     and version.valid_from < next_version.valid_from
                 ):
                     next_version = version
-            elif current_version is None:
-                current_version = version
-            elif previous_version is None:
-                previous_version = version
-                return previous_version, current_version, next_version
 
+            # Handle versions that are valid at or before the timestamp
+            else:  # version.valid_from <= timestamp
+                # First valid version becomes the current version
+                if current_version is None:
+                    current_version = version
+                # Second valid version becomes the previous version
+                elif previous_version is None:
+                    previous_version = version
+                    # Early return since we have found current and previous versions
+                    return previous_version, current_version, next_version
+
+        # Return the final state of all three version slots
         return previous_version, current_version, next_version