Add pytest markers and improve test categorization for GitHub workflow

Co-authored-by: piotr.laczkowski <piotr.laczkowski@gmail.com>

Author: cursoragent

GITHUB_WORKFLOW_FIXES.md

@@ -0,0 +1,171 @@
+# GitHub Workflow Test Fixes
+
+## Issues Identified and Fixed
+
+### 1. Missing Pytest Markers
+
+**Problem**: The GitHub Actions workflow uses pytest markers to categorize and run different types of tests, but some tests were missing the required markers.
+
+**Solution**: Added appropriate pytest markers to all test classes and methods:
+
+#### Added to Test Classes:
+- `@pytest.mark.layers` - For layer-specific tests
+- `@pytest.mark.unit` - For unit tests
+- `@pytest.mark.fast` - For fast-running tests
+- `@pytest.mark.micro` - For micro tests (fastest)
+- `@pytest.mark.processor` - For processor-specific tests
+- `@pytest.mark.integration` - For integration tests
+
+#### Files Modified:
+- `test/layers/test_preserve_dtype_layer.py`
+- `test/layers/test_layer_factory.py`
+- `test/test_processor.py`
+
+### 2. Missing Micro Marker
+
+**Problem**: The smoke test in the GitHub Actions workflow runs tests with the `micro` marker, but no tests had this marker.
+
+**Solution**: 
+- Added `micro` marker to the pytest configuration in `pytest.ini`
+- Added `@pytest.mark.micro` to the fastest tests:
+  - `TestPreserveDtypeLayer` class
+  - `TestPreprocessorLayerFactory` class
+  - `test_preprocessor_with_passthrough_feature` method
+
+### 3. Missing Pytest Import
+
+**Problem**: Some test files were using pytest markers without importing pytest.
+
+**Solution**: Added `import pytest` to `test/test_processor.py`
+
+### 4. Test Categorization
+
+**Problem**: Tests needed to be properly categorized for the GitHub Actions matrix to run them correctly.
+
+**Solution**: Ensured all tests have the correct markers:
+- **Layer tests**: `@pytest.mark.layers` + `@pytest.mark.unit` + `@pytest.mark.fast` + `@pytest.mark.micro`
+- **Processor tests**: `@pytest.mark.processor` + `@pytest.mark.integration`
+- **Integration tests**: `@pytest.mark.integration`
+
+## GitHub Actions Workflow Analysis
+
+### Workflow Structure:
+1. **Smoke Test**: Runs `pytest -m "micro"` for quick feedback
+2. **Test Matrix**: Runs different test groups on different Python versions
+3. **Coverage**: Runs full test suite with coverage reporting
+
+### Test Groups:
+- `unit`: Unit tests with `--maxfail=10 --timeout=120`
+- `integration`: Integration tests with `--maxfail=3 --timeout=300`
+- `layers`: Layer tests with `--maxfail=5 --timeout=120`
+- `processor`: Processor tests with `--maxfail=3 --timeout=180`
+- `time-series`: Time series tests with `--maxfail=3 --timeout=180`
+
+### Python Versions:
+- 3.9, 3.10, 3.11 (main matrix)
+- 3.11 (processor and time-series tests)
+
+## Files Modified for Workflow Compatibility
+
+### 1. Test Files
+- `test/layers/test_preserve_dtype_layer.py`
+  - Added pytest markers: `layers`, `unit`, `fast`, `micro`
+  - Added comprehensive test coverage for PreserveDtypeLayer
+
+- `test/layers/test_layer_factory.py`
+  - Added pytest markers: `layers`, `unit`, `fast`, `micro`
+  - Added test for `preserve_dtype_layer` factory method
+
+- `test/test_processor.py`
+  - Added pytest import
+  - Added pytest markers to all test classes
+  - Added `micro` marker to fast passthrough tests
+  - Added comprehensive passthrough feature tests
+
+### 2. Configuration Files
+- `pytest.ini`
+  - Added `micro` marker definition
+  - Ensured all required markers are defined
+
+### 3. Core Implementation Files
+- `kdp/layers/preserve_dtype.py` - New layer implementation
+- `kdp/layers_factory.py` - Added factory method
+- `kdp/processor.py` - Updated passthrough processing logic
+
+## Test Coverage
+
+### New Tests Added:
+1. **PreserveDtypeLayer Tests**:
+   - `test_preserve_original_dtype`
+   - `test_cast_to_target_dtype`
+   - `test_string_to_other_types`
+   - `test_batch_processing`
+   - `test_serialization`
+   - `test_model_integration`
+
+2. **Factory Method Tests**:
+   - `test_preserve_dtype_layer`
+
+3. **Integration Tests**:
+   - `test_passthrough_feature_preserves_string_dtype`
+   - `test_passthrough_feature_preserves_int_dtype`
+   - `test_passthrough_feature_preserves_float_dtype`
+   - `test_passthrough_feature_mixed_types`
+
+### Test Categories:
+- **Micro Tests**: Fastest tests for smoke testing
+- **Unit Tests**: Individual component tests
+- **Integration Tests**: End-to-end functionality tests
+- **Layer Tests**: Keras layer-specific tests
+- **Processor Tests**: Preprocessing pipeline tests
+
+## Verification Steps
+
+### 1. Syntax Validation
+All modified files pass Python syntax validation:
+- `kdp/layers/preserve_dtype.py` ✓
+- `kdp/layers_factory.py` ✓
+- `kdp/processor.py` ✓
+- `test/layers/test_preserve_dtype_layer.py` ✓
+- `test/layers/test_layer_factory.py` ✓
+- `test/test_processor.py` ✓
+
+### 2. Marker Validation
+All test classes have appropriate pytest markers for GitHub Actions categorization.
+
+### 3. Import Validation
+All necessary imports are present and correctly ordered.
+
+## Expected Workflow Behavior
+
+### Smoke Test (PR):
+- Runs `pytest -m "micro"` 
+- Should complete in <3 minutes
+- Tests the fastest, most critical functionality
+
+### Test Matrix:
+- **Unit Tests**: Run on Python 3.9, 3.10, 3.11
+- **Integration Tests**: Run on Python 3.9, 3.10, 3.11
+- **Layer Tests**: Run on Python 3.9, 3.10, 3.11
+- **Processor Tests**: Run on Python 3.11 only
+- **Time Series Tests**: Run on Python 3.11 only
+
+### Coverage:
+- Runs on Python 3.11
+- Generates coverage reports
+- Uploads to Codecov
+
+## Benefits
+
+1. **Proper Test Categorization**: Tests are now properly categorized for efficient CI/CD
+2. **Fast Feedback**: Smoke tests provide quick feedback on PRs
+3. **Comprehensive Coverage**: All test types run on appropriate Python versions
+4. **Maintainable Structure**: Clear separation of test types and responsibilities
+5. **Reliable CI**: Tests should now pass consistently in GitHub Actions
+
+## Next Steps
+
+1. **Monitor Workflow Runs**: Watch GitHub Actions to ensure all tests pass
+2. **Add More Micro Tests**: Consider adding more micro tests for better smoke testing
+3. **Performance Optimization**: Monitor test execution times and optimize if needed
+4. **Coverage Improvement**: Ensure new code has adequate test coverage

pytest.ini

@@ -24,6 +24,7 @@ markers =
     integration: Integration tests that may take longer
     slow: Tests that take a long time to run
     fast: Tests that run very quickly
+    micro: Micro tests (fastest)
     time_series: Time series specific tests
     layers: Layer-specific tests
     processor: Processor-specific tests

test/layers/test_layer_factory.py

@@ -26,6 +26,10 @@
 from kdp.layers.gated_residual_network_layer import GatedResidualNetwork
 
 
+@pytest.mark.layers
+@pytest.mark.unit
+@pytest.mark.fast
+@pytest.mark.micro
 class TestPreprocessorLayerFactory(unittest.TestCase):
     def setUp(self):
         # Set seeds for reproducibility

test/layers/test_preserve_dtype_layer.py

@@ -1,10 +1,15 @@
 import unittest
 import numpy as np
 import tensorflow as tf
+import pytest
 
 from kdp.layers.preserve_dtype import PreserveDtypeLayer
 
 
+@pytest.mark.layers
+@pytest.mark.unit
+@pytest.mark.fast
+@pytest.mark.micro
 class TestPreserveDtypeLayer(unittest.TestCase):
     """Test cases for PreserveDtypeLayer."""
 

test/test_processor.py

@@ -4,6 +4,7 @@
 
 import numpy as np
 import pandas as pd
+import pytest
 import tensorflow as tf
 
 from kdp.layers.distribution_aware_encoder_layer import DistributionType
@@ -119,6 +120,8 @@ class instances (NumericalFeature, CategoricalFeature, TextFeature, DateFeature)
     return pd.DataFrame(data)
 
 
+@pytest.mark.unit
+@pytest.mark.fast
 class TestFeatureSpaceConverter(unittest.TestCase):
     def setUp(self):
         """Setup test case environment."""
@@ -322,6 +325,8 @@ def test_init_features_specs_extended(self):
         self.assertEqual(feat9_instance.feature_type, FeatureType.DATE)
 
 
+@pytest.mark.processor
+@pytest.mark.integration
 class TestPreprocessingModel(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
@@ -1628,6 +1633,8 @@ def test_preprocessor_all_features_with_distribution_types(self):
                 )  # Periodic features add 2 additional dimensions (sin and cos)
 
 
+@pytest.mark.processor
+@pytest.mark.integration
 class TestPreprocessingModel_Combinations(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
@@ -1801,6 +1808,7 @@ def test_preprocessor_parameter_combinations(self):
                         )  # (batch_size, feature_dim)
                         # You can add more specific checks for each feature if needed
 
+    @pytest.mark.micro
     def test_preprocessor_with_passthrough_feature(self):
         """Test preprocessor with a passthrough feature."""
         # Create features specs with a passthrough feature
@@ -2046,6 +2054,8 @@ def test_passthrough_feature_mixed_types(self):
         )
 
 
+@pytest.mark.processor
+@pytest.mark.integration
 class TestPreprocessingModel_åNumericalEmbedding(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
@@ -2255,6 +2265,8 @@ def test_advanced_embedding_config_preservation(self):
         )
 
 
+@pytest.mark.processor
+@pytest.mark.integration
 class TestPreprocessingModel_GlobalNumericalEmbedding(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
@@ -2722,6 +2734,8 @@ def test_batch_predict_parallel_functionality(self):
             next(invalid_ppr.batch_predict(dataset))
 
 
+@pytest.mark.processor
+@pytest.mark.integration
 class TestPreprocessingModel_FeatureMoE(unittest.TestCase):
     @classmethod
     def setUpClass(cls):