Test fixes

Author: dbrattli

TEST_LINTING_PLAN.md

@@ -22,51 +22,74 @@
 
 ## Staged Approach
 
-### Stage 0: Format All Test Files (Pre-work)
+### Stage 0: Format All Test Files (Pre-work) ✅ COMPLETED
 
 **Goal**: Handle all formatting issues upfront before type annotations
 
 **Tasks**:
 
-1. Run `ruff format tests/` to auto-format all test files
-2. Review and commit formatting changes
-3. Verify tests still pass after formatting
+1. ✅ Run `ruff format tests/` - 19 files reformatted
+2. ✅ Updated configuration to use specific directory exclusions
+3. ✅ Verified tests still pass after formatting
 
 **Rationale**: Separating formatting from type annotation work makes it easier to review changes and ensures we start from a clean, consistent base.
 
-**Estimated Effort**: ~15-30 minutes
+**Actual Effort**: ~30 minutes
 
-### Stage 1: Infrastructure & Smallest Modules (8 files)
+### Stage 1: Infrastructure & Smallest Modules (8 files) ✅ COMPLETED
 
 **Goal**: Validate the approach and establish patterns
 
 **Tasks**:
 
-1. ✅ **COMPLETED**: Updated ruff configuration to match pyright (specific directory exclusions)
-2. Run `ruff check --fix` on Stage 1 files for auto-fixable issues
-3. Fix **test_core** (4 files) - Core functionality tests
-4. Fix **test_disposables** (2 files) - Disposable tests
-5. Fix **test_testing** (2 files) - Testing utilities tests
-6. Document common patterns and solutions
+1. ✅ Updated ruff configuration to match pyright (specific directory exclusions)
+2. ✅ Ran `ruff check --fix --unsafe-fixes` - auto-fixed 16 errors
+3. ✅ Fixed **test_core/test_priorityqueue.py** - 0 errors
+4. ✅ Fixed **test_core/test_observer.py** - 0 errors
+5. ✅ Fixed **test_core/test_notification.py** - 0 errors (largest file, most complex)
+6. ✅ Fixed **test_disposables/test_disposable.py** - 0 errors (auto-fixed)
+7. ✅ Fixed **test_testing/test_marbles.py** - 0 errors
+8. ✅ All 75 Stage 1 tests pass
+
+**Patterns Discovered**:
+
+- Add `-> None` return types to all test functions
+- Use explicit type parameters for generics (e.g., `OnError[int]`, `OnCompleted[int]`)
+- Convert string exceptions to `Exception("message")` objects
+- Use `cast()` with documented justifications for test patterns that go beyond public API
+- Replace `== None` with `is not None` or `is None`
+- Add type annotations to all observer classes and helper functions
 
 **Rationale**: These are likely the simplest and will help identify common patterns and issues.
 
-**Estimated Effort**: ~2-4 hours (includes setup)
+**Actual Effort**: ~3 hours
 
-### Stage 2: Medium Modules (9 files)
+### Stage 2: Medium Modules (9 files) ⚠️ PARTIAL - test_integration COMPLETE
 
 **Goal**: Build confidence with isolated modules
 
+**Status**: test_integration complete, test_subject deferred to preserve commit checkpoint
+
 **Tasks**:
 
-1. Fix **test_subject** (5 files) - Subject tests
-2. Fix **test_integration** (2 files) - Integration tests
-3. Run full test suite to ensure no regressions
-4. Update pattern documentation
+1. ⏳ Fix **test_subject** (5 files) - Deferred (requires ~2000 lines of fixes)
+2. ✅ Fix **test_integration** (2 files) - COMPLETE
+   - ✅ **test_integration/test_concat_repeat.py** - 0 errors
+   - ✅ **test_integration/test_group_reduce.py** - 0 errors
+   - ✅ All 3 integration tests pass
+3. ✅ Excluded test_subject from pyproject.toml for pre-commit checkpoint
+4. ✅ Verified all enabled tests pass (78 tests total)
 
-**Rationale**: Still manageable size, builds confidence before tackling large modules.
+**Additional Patterns Discovered**:
 
-**Estimated Effort**: ~1-2 hours
+- Marble testing requires `None, None` parameters for value_lookup and error_lookup
+- Complex operator chains (group_by, flat_map): Extract helper function with explicit `Callable[[Observable[Any]], Observable[Any]]` type
+- Integration tests validate runtime behavior, so `Any` types with documented justification are acceptable
+- GroupedObservable type inference issues: Use helper functions instead of inline lambdas
+
+**Rationale**: Still manageable size, builds confidence before tackling large modules. Split to allow checkpoint commit.
+
+**Actual Effort**: ~1 hour (test_integration only)
 
 ### Stage 3: Scheduler Module (27 files)
 
@@ -271,21 +294,23 @@ typeCheckingMode = "strict"
   - [x] Run `ruff format tests/` (19 files reformatted)
   - [x] Review and commit formatting changes (commit: 73495f83)
   - [x] Verify tests still pass
-  - [x] Update ruff config to use specific directory exclusions (commit: pending)
+  - [x] Update ruff config to use specific directory exclusions (commit: ecf450ee)
 
   **Note**: Formatting worked even with blanket "tests" exclusion because explicitly passing paths to ruff overrides excludes by default.
 
-- [ ] Stage 1: Infrastructure & Smallest Modules (8 files)
-  - [ ] Update configuration files
-  - [ ] Fix test_core (4 files)
-  - [ ] Fix test_disposables (2 files)
-  - [ ] Fix test_testing (2 files)
-  - [ ] Document patterns
-
-- [ ] Stage 2: Medium Modules (9 files)
-  - [ ] Fix test_subject (5 files)
-  - [ ] Fix test_integration (2 files)
-  - [ ] Run full test suite
+- [x] Stage 1: Infrastructure & Smallest Modules (8 files) ✅
+  - [x] Update configuration files
+  - [x] Fix test_core (4 files) - 0 errors
+  - [x] Fix test_disposables (2 files) - 0 errors
+  - [x] Fix test_testing (2 files) - 0 errors
+  - [x] Document patterns
+  - [x] All 75 tests pass
+
+- [x] Stage 2: Medium Modules (9 files) ⚠️ PARTIAL
+  - [ ] Fix test_subject (5 files) - Deferred
+  - [x] Fix test_integration (2 files) - 0 errors, 3 tests pass
+  - [x] Exclude test_subject from pyproject.toml
+  - [x] Run enabled tests (78 tests total)
 
 - [ ] Stage 3: Scheduler Module (27 files)
   - [ ] Fix test_scheduler files

pyproject.toml

@@ -75,9 +75,8 @@ exclude = [
     "notebooks",
     "examples",
     # Test directories - remove as each stage is completed
-    # Stage 1 directories removed - now enabled for linting
+    # Stage 1 complete, Stage 2 partial (test_integration complete)
     "tests/test_subject",
-    "tests/test_integration",
     "tests/test_scheduler",
     "tests/test_observable",
 ]
@@ -101,7 +100,6 @@ known-first-party = ["reactivex"]
 python_version = "3.10"
 follow_imports = "silent"
 files = ["reactivex"]
-exclude = ["reactivex/operators/_\\w.*\\.py$"] # mypy will eventually catch up
 disallow_any_generics = true
 disallow_untyped_defs = true
 
@@ -112,9 +110,8 @@ asyncio_mode = "strict"
 [tool.pyright]
 include = ["reactivex", "tests"]
 exclude = [
-    # Stage 1 directories removed - now enabled for type checking
+    # Stage 1 complete, Stage 2 partial (test_integration complete)
     "tests/test_subject",
-    "tests/test_integration",
     "tests/test_scheduler",
     "tests/test_observable",
 ]

reactivex/__init__.py

@@ -64,7 +64,7 @@ def amb(*sources: Observable[_T]) -> Observable[_T]:
 def case(
     mapper: Callable[[], _TKey],
     sources: Mapping[_TKey, Observable[_T]],
-    default_source: Union[Observable[_T], "Future[_T]"] | None = None,
+    default_source: Observable[_T] | Future[_T] | None = None,
 ) -> Observable[_T]:
     """Uses mapper to determine which source in sources to use.
 

tests/test_integration/test_concat_repeat.py

@@ -5,11 +5,11 @@
 
 
 class TestConcatIntegration(unittest.TestCase):
-    def test_concat_repeat(self):
-        with marbles_testing() as (start, cold, hot, exp):
-            e1 = cold("-e11-e12|")
-            e2 = cold("-e21-e22|")
-            ex = exp("-e11-e12-e21-e22-e11-e12-e21-e22|")
+    def test_concat_repeat(self) -> None:
+        with marbles_testing() as (start, cold, _hot, exp):
+            e1 = cold("-e11-e12|", None, None)
+            e2 = cold("-e21-e22|", None, None)
+            ex = exp("-e11-e12-e21-e22-e11-e12-e21-e22|", None, None)
 
             obs = e1.pipe(ops.concat(e2), ops.repeat(2))
 

tests/test_integration/test_group_reduce.py

@@ -1,34 +1,50 @@
 import unittest
+from collections.abc import Callable
+from typing import Any
 
 import reactivex
+from reactivex import Observable
 from reactivex import operators as ops
 
 
 class TestGroupByReduce(unittest.TestCase):
-    def test_groupby_count(self):
-        res = []
-        counts = reactivex.from_(range(10)).pipe(
+    def test_groupby_count(self) -> None:
+        res: list[Any] = []
+
+        # Integration test: GroupedObservable types validated at runtime
+        def flat_map_fn(i: Any) -> Any:
+            return i.pipe(
+                ops.count(),
+                ops.map(lambda ii: (i.key, ii)),
+            )
+
+        flat_map_op: Callable[[Observable[Any]], Observable[Any]] = ops.flat_map(
+            flat_map_fn
+        )
+
+        counts: Any = reactivex.from_(range(10)).pipe(
             ops.group_by(lambda i: "even" if i % 2 == 0 else "odd"),
-            ops.flat_map(
-                lambda i: i.pipe(
-                    ops.count(),
-                    ops.map(lambda ii: (i.key, ii)),
-                )
-            ),
+            flat_map_op,
         )
 
         counts.subscribe(on_next=res.append)
         assert res == [("even", 5), ("odd", 5)]
 
-    def test_window_sum(self):
-        res = []
-        reactivex.from_(range(6)).pipe(
+    def test_window_sum(self) -> None:
+        res: list[Any] = []
+
+        # Integration test: windowed Observable types validated at runtime
+        def flat_map_fn(i: Any) -> Any:
+            return i.pipe(ops.sum())
+
+        flat_map_op: Callable[[Observable[Any]], Observable[Any]] = ops.flat_map(
+            flat_map_fn
+        )
+
+        obs: Any = reactivex.from_(range(6)).pipe(
             ops.window_with_count(count=3, skip=1),
-            ops.flat_map(
-                lambda i: i.pipe(
-                    ops.sum(),
-                )
-            ),
-        ).subscribe(on_next=res.append)
+            flat_map_op,
+        )
+        obs.subscribe(on_next=res.append)
 
         assert res == [3, 6, 9, 12, 9, 5, 0]