initial version

tests/test_feature_matrix.py

@@ -0,0 +1,212 @@
+"""
+Tests for the ADB Feature Compatibility Matrix YAML and CLI.
+
+Matrix YAML: kb/compatibility/adb-feature-matrix.yaml
+CLI module:  tools/feature_matrix_cli.py
+"""
+
+import csv
+import io
+import sys
+from pathlib import Path
+
+import pytest
+import yaml
+
+# ---------------------------------------------------------------------------
+# Path setup
+# ---------------------------------------------------------------------------
+PROJECT_ROOT = Path(__file__).resolve().parent.parent
+MATRIX_PATH = PROJECT_ROOT / "kb" / "compatibility" / "adb-feature-matrix.yaml"
+TOOLS_DIR = PROJECT_ROOT / "tools"
+
+# Make the tools directory importable so we can import the CLI module.
+if str(TOOLS_DIR) not in sys.path:
+    sys.path.insert(0, str(TOOLS_DIR))
+
+try:
+    import feature_matrix_cli as cli
+
+    CLI_AVAILABLE = True
+except ImportError:
+    CLI_AVAILABLE = False
+
+VALID_STATUSES = {"GA", "GA_CAVEAT", "PREVIEW", "LIMITED", "NOT_AVAIL", "BROKEN", "UNTESTED"}
+
+
+# ---------------------------------------------------------------------------
+# Fixtures
+# ---------------------------------------------------------------------------
+@pytest.fixture(scope="module")
+def matrix_data():
+    """Load the feature-matrix YAML once per module."""
+    with open(MATRIX_PATH, "r") as fh:
+        return yaml.safe_load(fh)
+
+
+@pytest.fixture(scope="module")
+def features(matrix_data):
+    """Return the list of feature entries."""
+    return matrix_data["features"]
+
+
+# ---------------------------------------------------------------------------
+# YAML structure tests
+# ---------------------------------------------------------------------------
+class TestMatrixYAML:
+    def test_matrix_loads(self, matrix_data):
+        """YAML loads without errors and contains expected top-level keys."""
+        assert matrix_data is not None
+        assert "features" in matrix_data
+        assert "versions" in matrix_data
+        assert "deployment_types" in matrix_data
+
+    def test_all_features_have_at_least_one_deployment(self, features):
+        """Every feature must have a non-empty matrix (at least one deployment type)."""
+        for feat in features:
+            matrix = feat.get("matrix", {})
+            assert matrix, (
+                f"Feature '{feat['name']}' has an empty matrix — "
+                "at least one deployment type must be present."
+            )
+
+    def test_all_statuses_are_valid(self, features):
+        """Every status value across the entire matrix must be in the allowed set."""
+        for feat in features:
+            for deploy_id, versions in feat.get("matrix", {}).items():
+                for ver, entry in versions.items():
+                    status = entry if isinstance(entry, str) else entry.get("status")
+                    assert status in VALID_STATUSES, (
+                        f"Feature '{feat['name']}', deployment '{deploy_id}', "
+                        f"version '{ver}' has invalid status '{status}'. "
+                        f"Allowed: {VALID_STATUSES}"
+                    )
+
+
+# ---------------------------------------------------------------------------
+# CLI function tests — use internal helpers from feature_matrix_cli
+# ---------------------------------------------------------------------------
+requires_cli = pytest.mark.skipif(not CLI_AVAILABLE, reason="feature_matrix_cli not available")
+
+
+@requires_cli
+class TestMatrixCLICheck:
+    def test_check_returns_correct_status(self):
+        """check('Auto Scaling', 'adb_s', '23ai') should contain 'GA_CAVEAT'."""
+        data = cli.load_matrix(str(MATRIX_PATH))
+        matches = cli.find_features(data, "Auto Scaling")
+        assert len(matches) >= 1, "Expected at least one match for 'Auto Scaling'"
+        feature = matches[0]
+        cell = cli.get_cell(feature, "adb_s", "23ai")
+        assert cell is not None, "Expected a cell for Auto Scaling / adb_s / 23ai"
+        assert "GA_CAVEAT" in cell.get("status", ""), (
+            f"Expected GA_CAVEAT for Auto Scaling / adb_s / 23ai, got: {cell}"
+        )
+
+    def test_check_unknown_feature_returns_error(self):
+        """check with a nonexistent feature should return no matches."""
+        data = cli.load_matrix(str(MATRIX_PATH))
+        matches = cli.find_features(data, "Nonexistent Feature")
+        assert len(matches) == 0, (
+            f"Expected no matches for 'Nonexistent Feature', got {len(matches)}"
+        )
+
+
+@requires_cli
+class TestMatrixCLICompare:
+    def test_compare_returns_all_features(self, features):
+        """Compare output should cover every feature in the matrix."""
+        data = cli.load_matrix(str(MATRIX_PATH))
+        feature_names = {f["name"] for f in features}
+        # Simulate what cmd_compare does: iterate all features and get cells
+        compared = set()
+        for feature in data["features"]:
+            cell1 = cli.get_cell(feature, "adb_s", "23ai")
+            cell2 = cli.get_cell(feature, "exacs", "23ai")
+            # Both cells may be None (UNTESTED), but the feature is still compared
+            compared.add(feature["name"])
+        assert feature_names == compared, (
+            f"Missing features in compare: {feature_names - compared}"
+        )
+
+
+@requires_cli
+class TestMatrixCLIGaps:
+    def test_gaps_finds_not_available(self):
+        """gaps('dbcs_ee', '23ai') should include features marked NOT_AVAIL."""
+        data = cli.load_matrix(str(MATRIX_PATH))
+        gap_statuses = {"NOT_AVAIL", "BROKEN", "LIMITED"}
+        gaps = []
+        for feature in data["features"]:
+            cell = cli.get_cell(feature, "dbcs_ee", "23ai")
+            if cell is not None:
+                status = cell.get("status", "UNTESTED")
+                if status in gap_statuses:
+                    gaps.append((feature["name"], status))
+
+        assert len(gaps) > 0, "Expected at least one gap for dbcs_ee / 23ai"
+        not_avail_gaps = [g for g in gaps if g[1] == "NOT_AVAIL"]
+        assert len(not_avail_gaps) > 0, (
+            "Expected at least one NOT_AVAIL gap for dbcs_ee / 23ai"
+        )
+
+
+# ---------------------------------------------------------------------------
+# Export tests
+# ---------------------------------------------------------------------------
+@requires_cli
+class TestMatrixCLIExport:
+    def test_export_markdown_is_valid(self, matrix_data):
+        """Markdown export should contain a header row with | separators."""
+        data = cli.load_matrix(str(MATRIX_PATH))
+        versions = cli.get_version_ids(data)
+        deployments = cli.get_deployment_ids(data)
+
+        columns = [(d, v) for d in deployments for v in versions]
+        col_labels = [f"{d}/{v}" for d, v in columns]
+
+        # Capture the markdown output by calling the internal function
+        captured = io.StringIO()
+        old_stdout = sys.stdout
+        sys.stdout = captured
+        try:
+            cli._export_markdown(data, columns, col_labels)
+        finally:
+            sys.stdout = old_stdout
+
+        content = captured.getvalue()
+        lines = [ln for ln in content.splitlines() if ln.strip()]
+        assert len(lines) >= 2, "Markdown export should have at least a header and separator row"
+        # Header row must use pipe separators.
+        assert "|" in lines[0], f"Header row missing '|' separators: {lines[0]}"
+        # Second row is the --- separator row.
+        assert "|" in lines[1], f"Separator row missing '|': {lines[1]}"
+
+    def test_export_csv_is_valid(self, matrix_data):
+        """CSV export should be parseable with csv.reader."""
+        data = cli.load_matrix(str(MATRIX_PATH))
+        versions = cli.get_version_ids(data)
+        deployments = cli.get_deployment_ids(data)
+
+        columns = [(d, v) for d in deployments for v in versions]
+        col_labels = [f"{d}/{v}" for d, v in columns]
+
+        # Capture the CSV output
+        captured = io.StringIO()
+        old_stdout = sys.stdout
+        sys.stdout = captured
+        try:
+            cli._export_csv(data, columns, col_labels)
+        finally:
+            sys.stdout = old_stdout
+
+        content = captured.getvalue()
+        reader = csv.reader(io.StringIO(content))
+        rows = list(reader)
+        assert len(rows) >= 2, "CSV export should have at least a header row and one data row"
+        # All rows should have the same number of columns.
+        col_count = len(rows[0])
+        for i, row in enumerate(rows):
+            assert len(row) == col_count, (
+                f"Row {i} has {len(row)} columns, expected {col_count}"
+            )