ara-cli 0.1.9.50__py3-none-any.whl → 0.1.9.51__py3-none-any.whl

ara_cli/tests/test_artefact_lister.py

@@ -1,6 +1,8 @@
 import pytest
 from unittest.mock import MagicMock, patch
 from ara_cli.artefact_lister import ArtefactLister
+from ara_cli.list_filter import ListFilter
+from ara_cli.artefact_models.artefact_model import ArtefactType
 
 
 @pytest.fixture
@@ -8,197 +10,564 @@ def artefact_lister():
     return ArtefactLister()
 
 
-@pytest.mark.parametrize("artefact_content, artefact_path", [
-    ("content1", "path1"),
-    ("content2", "path2"),
-    ("content3", "path3"),
-])
-def test_artefact_content_retrieval(artefact_content, artefact_path):
+@pytest.mark.parametrize(
+    "users, status, tags, expected_tags",
+    [
+        # Normal case with all fields populated
+        (
+            ["john", "alice"],
+            "in-progress",
+            ["important", "urgent"],
+            ["user_john", "user_alice", "in-progress", "important", "urgent"]
+        ),
+        # Case with empty users
+        (
+            [],
+            "to-do",
+            ["feature", "backend"],
+            ["to-do", "feature", "backend"]
+        ),
+        # Case with empty tags
+        (
+            ["bob"],
+            "done",
+            [],
+            ["user_bob", "done"]
+        ),
+        # Case with all empty fields
+        (
+            [],
+            "",
+            [],
+            [""]
+        ),
+        # Case with None values for tags (should handle gracefully)
+        (
+            ["admin"],
+            "closed",
+            None,
+            ["user_admin", "closed"]
+        ),
+    ]
+)
+def test_artefact_tags_retrieval(users, status, tags, expected_tags):
+    # Create a mock artefact with the specified attributes
     artefact_mock = MagicMock()
-    artefact_mock.content = artefact_content
-    artefact_mock.file_path = artefact_path
+    artefact_mock.users = users
+    artefact_mock.status = status
+    artefact_mock.tags = tags if tags is not None else []
+
+    # Call the method under test
+    result = ArtefactLister.artefact_tags_retrieval(artefact_mock)
+
+    # Verify the result
+    assert result == expected_tags
+
+
+def test_artefact_tags_retrieval_with_none():
+    # Test with None artefact
+    result = ArtefactLister.artefact_tags_retrieval(None)
+    assert result == []
+
+
+@pytest.mark.parametrize(
+    "classified_files, list_filter, filter_result",
+    [
+        # Case 1: No filter applied
+        (
+            {"type1": [MagicMock(), MagicMock()]},
+            None,
+            {"type1": [MagicMock(), MagicMock()]}
+        ),
+        # Case 2: Filter with include tags
+        (
+            {"type1": [MagicMock(), MagicMock()]},
+            ListFilter(include_tags=["tag1"]),
+            {"type1": [MagicMock()]}
+        ),
+        # Case 3: Filter with exclude tags
+        (
+            {"type1": [MagicMock(), MagicMock()], "type2": [MagicMock()]},
+            ListFilter(exclude_tags=["tag2"]),
+            {"type1": [MagicMock()], "type2": []}
+        ),
+        # Case 4: Empty result after filtering
+        (
+            {"type1": [MagicMock(), MagicMock()]},
+            ListFilter(include_tags=["nonexistent"]),
+            {"type1": []}
+        ),
+        # Case 5: Multiple artefact types
+        (
+            {"type1": [MagicMock()], "type2": [MagicMock(), MagicMock()]},
+            ListFilter(exclude_extension=[".txt"]),
+            {"type1": [], "type2": [MagicMock()]}
+        ),
+    ],
+)
+def test_filter_artefacts(
+    artefact_lister,
+    classified_files,
+    list_filter,
+    filter_result
+):
+    # Mock the filter_list function
+    with patch("ara_cli.artefact_lister.filter_list") as mock_filter_list:
+        mock_filter_list.return_value = filter_result
+
+        # Call the method under test
+        result = artefact_lister.filter_artefacts(classified_files, list_filter)
+
+        # Verify filter_list was called with correct parameters
+        mock_filter_list.assert_called_once_with(
+            list_to_filter=classified_files,
+            list_filter=list_filter,
+            content_retrieval_strategy=ArtefactLister.artefact_content_retrieval,
+            file_path_retrieval=ArtefactLister.artefact_path_retrieval,
+            tag_retrieval=ArtefactLister.artefact_tags_retrieval
+        )
+
+        # Verify the structure matches (don't compare the actual MagicMock objects)
+        assert set(result.keys()) == set(filter_result.keys())
+        for key in filter_result:
+            assert len(result[key]) == len(filter_result[key])
+
+
+@pytest.mark.parametrize("artefact_content", ["content1", "content2", "content3"])
+def test_artefact_content_retrieval(artefact_content):
+    artefact_mock = MagicMock()
+    artefact_mock.serialize.return_value = artefact_content  # Mock serialize()
 
     content = ArtefactLister.artefact_content_retrieval(artefact_mock)
     assert content == artefact_content
 
 
-@pytest.mark.parametrize("artefact_content, artefact_path", [
-    ("content1", "path1"),
-    ("content2", "path2"),
-    ("content3", "path3"),
-])
-def test_artefact_path_retrieval(artefact_content, artefact_path):
+@pytest.mark.parametrize(
+    "file_path",
+    [
+        ("./ara/userstories/test.userstory"),
+        ("./ara/epics/test.epic"),
+    ],
+)
+def test_artefact_path_retrieval(file_path):
     artefact_mock = MagicMock()
-    artefact_mock.content = artefact_content
-    artefact_mock.file_path = artefact_path
+    artefact_mock.file_path = file_path
 
     path = ArtefactLister.artefact_path_retrieval(artefact_mock)
-    assert path == artefact_path
-
-
-@pytest.mark.parametrize("tags, navigate_to_target", [
-    (None, False),
-    (["tag1", "tag2"], False),
-    (["tag1"], True),
-    ([], True)
-])
-@patch('ara_cli.artefact_lister.FileClassifier')
-@patch('ara_cli.artefact_lister.DirectoryNavigator')
-def test_list_files(mock_directory_navigator, mock_file_classifier, artefact_lister, tags, navigate_to_target):
-    mock_navigator_instance = mock_directory_navigator.return_value
-    mock_navigator_instance.navigate_to_target = MagicMock()
-
-    mock_classifier_instance = mock_file_classifier.return_value
-    mock_classifier_instance.classify_files = MagicMock(return_value={'mocked_files': []})
-    mock_classifier_instance.print_classified_files = MagicMock()
-
-    artefact_lister.list_files(tags=tags, navigate_to_target=navigate_to_target)
-
-    if navigate_to_target:
-        mock_navigator_instance.navigate_to_target.assert_called_once()
-    else:
-        mock_navigator_instance.navigate_to_target.assert_not_called()
-
-    mock_classifier_instance.classify_files.assert_called_once_with(tags=tags)
-
-    mock_classifier_instance.print_classified_files.assert_called_once_with({'mocked_files': []})
-
-
-@pytest.mark.parametrize("classifier, artefact_name, classified_artefacts, expected_suggestions", [
-    ("classifier1", "missing_artefact", {"classifier1": []}, []),
-    ("classifier2", "artefact1", {"classifier2": [MagicMock(file_name="artefact1")]}, None)
-])
-@patch('ara_cli.artefact_lister.FileClassifier')
-@patch('ara_cli.artefact_lister.suggest_close_name_matches')
-@patch('ara_cli.artefact_lister.ArtefactReader')
-def test_list_branch_no_match(mock_artefact_reader, mock_suggest, mock_file_classifier, classifier, artefact_name, classified_artefacts, expected_suggestions, artefact_lister):
-    mock_classifier_instance = mock_file_classifier.return_value
-    mock_classifier_instance.classify_files = MagicMock(return_value=classified_artefacts)
-    mock_classifier_instance.print_classified_files = MagicMock()
-
-    mock_artefact_reader.step_through_value_chain = MagicMock()
-
-    artefact_lister.list_branch(classifier, artefact_name)
-
-    if expected_suggestions is not None:
-        mock_suggest.assert_called_once_with(artefact_name, [])
-        mock_artefact_reader.step_through_value_chain.assert_not_called()
-        mock_classifier_instance.print_classified_files.assert_not_called()
-    else:
-        mock_suggest.assert_not_called()
-        mock_artefact_reader.step_through_value_chain.assert_called_once_with(
-            artefact_name=artefact_name,
-            classifier=classifier,
-            artefacts_by_classifier={classifier: []}
-        )
-        mock_classifier_instance.print_classified_files.assert_called_once()
-
-
-@pytest.mark.parametrize("classifier, artefact_name, classified_artefacts, expected_suggestions", [
-    ("classifier1", "missing_artefact", {"classifier1": []}, []),
-    ("classifier2", "artefact1", {"classifier2": [MagicMock(file_name="artefact1")]}, None)
-])
-@patch('ara_cli.artefact_lister.FileClassifier')
-@patch('ara_cli.artefact_lister.suggest_close_name_matches')
-@patch('ara_cli.artefact_lister.ArtefactReader')
-def test_list_children_no_match(mock_artefact_reader, mock_suggest, mock_file_classifier, classifier, artefact_name, classified_artefacts, expected_suggestions, artefact_lister):
-    # Mock the FileClassifier and its methods
-    mock_classifier_instance = mock_file_classifier.return_value
-    mock_classifier_instance.classify_files = MagicMock(return_value=classified_artefacts)
-    mock_classifier_instance.print_classified_files = MagicMock()
-
-    mock_artefact_reader.find_children = MagicMock()
-
-    artefact_lister.list_children(classifier, artefact_name)
-
-    if expected_suggestions is not None:
-        mock_suggest.assert_called_once_with(artefact_name, [])
-        mock_artefact_reader.find_children.assert_not_called()
-        mock_classifier_instance.print_classified_files.assert_not_called()
-    else:
-        mock_suggest.assert_not_called()
+    assert path == file_path
+
+
+@pytest.mark.parametrize(
+    "tags, navigate_to_target, list_filter, mock_artefacts, filtered_artefacts, expected_filtered",
+    [
+        # Test with no filter
+        (
+            None,
+            False,
+            None,
+            {"type1": [MagicMock(), MagicMock()]},
+            {"type1": [MagicMock(), MagicMock()]},
+            {"type1": [MagicMock(), MagicMock()]},
+        ),
+        # Test with filter applied
+        (
+            ["tag1"],
+            False,
+            ListFilter(include_tags=["tag1"]),
+            {"type1": [MagicMock(), MagicMock()]},
+            {"type1": [MagicMock()]},
+            {"type1": [MagicMock()]},
+        ),
+        # Test with None values in artefact list
+        (
+            None,
+            False,
+            None,
+            {"type1": [MagicMock(), None, MagicMock()]},
+            {"type1": [MagicMock(), None, MagicMock()]},
+            {"type1": [MagicMock(), MagicMock()]},
+        ),
+        # Test with empty filtered results
+        (
+            ["tag1"],
+            False,
+            ListFilter(include_tags=["nonexistent"]),
+            {"type1": [MagicMock(), MagicMock()]},
+            {"type1": []},
+            {"type1": []},
+        ),
+        # Test with multiple artefact types
+        (
+            None,
+            True,
+            ListFilter(exclude_extension=[".txt"]),
+            {"type1": [MagicMock()], "type2": [MagicMock(), MagicMock()]},
+            {"type1": [], "type2": [MagicMock()]},
+            {"type1": [], "type2": [MagicMock()]},
+        ),
+    ],
+)
+def test_list_files(
+    artefact_lister,
+    tags,
+    navigate_to_target,
+    list_filter,
+    mock_artefacts,
+    filtered_artefacts,
+    expected_filtered,
+):
+    # Mock ArtefactReader.read_artefacts
+    with patch("ara_cli.artefact_lister.ArtefactReader") as mock_reader:
+        mock_reader.read_artefacts.return_value = mock_artefacts
+
+        # Mock filter_artefacts method
+        artefact_lister.filter_artefacts = MagicMock(return_value=filtered_artefacts)
+
+        # Mock FileClassifier
+        with patch("ara_cli.artefact_lister.FileClassifier") as mock_file_classifier:
+            mock_classifier_instance = MagicMock()
+            mock_file_classifier.return_value = mock_classifier_instance
+
+            # Call the method under test
+            artefact_lister.list_files(
+                tags=tags,
+                navigate_to_target=navigate_to_target,
+                list_filter=list_filter,
+            )
+
+            # Verify the correct calls were made
+            mock_reader.read_artefacts.assert_called_once_with(tags=tags)
+            artefact_lister.filter_artefacts.assert_called_once_with(
+                mock_artefacts, list_filter
+            )
+
+            # Check that the correct filtered list is passed to print_classified_files
+            # We need to check structure rather than exact equality because MagicMock instances are different
+            call_arg = mock_classifier_instance.print_classified_files.call_args[0][0]
+
+            # Verify structure matches expected filtered artefacts
+            assert set(call_arg.keys()) == set(expected_filtered.keys())
+            for key in expected_filtered:
+                assert len(call_arg[key]) == len(expected_filtered[key])
+
+            # Verify FileClassifier was initialized with the correct file system
+            mock_file_classifier.assert_called_once_with(artefact_lister.file_system)
+
+
+@pytest.mark.parametrize(
+    "classifier, artefact_name, list_filter, classified_artefacts, artefact_info, matching_artefacts, child_artefacts, filtered_artefacts",
+    [
+        # Case 1: Artefact found, with children, no filter
+        (
+            "epic",
+            "Epic1",
+            None,
+            {"epic": [{"title": "Epic1"}, {"title": "Epic2"}]},
+            [{"title": "Epic1"}, {"title": "Epic2"}],
+            [{"title": "Epic1"}],
+            {"userstory": ["Story1", "Story2"]},
+            {"userstory": ["Story1", "Story2"]},
+        ),
+        # Case 2: Artefact found, with children, with filter
+        (
+            "epic",
+            "Epic1",
+            ListFilter(include_tags=["tag1"]),
+            {"epic": [{"title": "Epic1"}, {"title": "Epic2"}]},
+            [{"title": "Epic1"}, {"title": "Epic2"}],
+            [{"title": "Epic1"}],
+            {"userstory": ["Story1", "Story2"]},
+            {"userstory": ["Story1"]},  # Filtered result
+        ),
+        # Case 3: Artefact not found
+        (
+            "epic",
+            "NonExistentEpic",
+            None,
+            {"epic": [{"title": "Epic1"}, {"title": "Epic2"}]},
+            [{"title": "Epic1"}, {"title": "Epic2"}],
+            [],
+            {},
+            {},
+        ),
+    ],
+)
+def test_list_children(
+    artefact_lister,
+    classifier,
+    artefact_name,
+    list_filter,
+    classified_artefacts,
+    artefact_info,
+    matching_artefacts,
+    child_artefacts,
+    filtered_artefacts,
+):
+    # Setup mocks
+    with patch("ara_cli.artefact_lister.FileClassifier") as mock_file_classifier, patch(
+        "ara_cli.artefact_lister.suggest_close_name_matches"
+    ) as mock_suggest, patch(
+        "ara_cli.artefact_lister.ArtefactReader"
+    ) as mock_artefact_reader:
+
+        # Configure mock FileClassifier
+        mock_classifier_instance = MagicMock()
+        mock_file_classifier.return_value = mock_classifier_instance
+        mock_classifier_instance.classify_files_new.return_value = classified_artefacts
+
+        # Configure ArtefactReader mock
+        mock_artefact_reader.find_children.return_value = child_artefacts
+
+        # Mock filter_artefacts method
+        artefact_lister.filter_artefacts = MagicMock(return_value=filtered_artefacts)
+
+        # Call the method under test
+        artefact_lister.list_children(classifier, artefact_name, list_filter)
+
+        # Verify interactions
+        mock_classifier_instance.classify_files_new.assert_called_once()
+
+        # Check if suggestions were made for non-existent artefacts
+        if not matching_artefacts:
+            mock_suggest.assert_called_once_with(
+                artefact_name, [info["title"] for info in artefact_info]
+            )
+        else:
+            mock_suggest.assert_not_called()
+
+        # Verify ArtefactReader.find_children was called
         mock_artefact_reader.find_children.assert_called_once_with(
-            artefact_name=artefact_name,
-            classifier=classifier
+            artefact_name=artefact_name, classifier=classifier
+        )
+
+        # Verify filter_artefacts was called with correct parameters
+        artefact_lister.filter_artefacts.assert_called_once_with(
+            child_artefacts, list_filter
         )
-        mock_classifier_instance.print_classified_files.assert_called_once()
-
-@pytest.mark.parametrize("classifier, artefact_name, child_artefacts, filtered_child_artefacts", [
-    ("classifier2", "artefact1", [MagicMock(), MagicMock()], [MagicMock()]),
-])
-@patch('ara_cli.artefact_lister.FileClassifier')
-@patch('ara_cli.artefact_lister.filter_list')
-@patch('ara_cli.artefact_lister.ArtefactReader')
-def test_list_children_with_children(mock_artefact_reader, mock_filter_list, mock_file_classifier, classifier, artefact_name, child_artefacts, filtered_child_artefacts, artefact_lister):
-    mock_classifier_instance = mock_file_classifier.return_value
-    mock_classifier_instance.classify_files = MagicMock(return_value={classifier: [MagicMock(file_name=artefact_name)]})
-    mock_classifier_instance.print_classified_files = MagicMock()
-
-    mock_artefact_reader.find_children = MagicMock(return_value=child_artefacts)
-
-    mock_filter_list.return_value = filtered_child_artefacts
-
-    artefact_lister.list_children(classifier, artefact_name)
-
-    mock_artefact_reader.find_children.assert_called_once_with(
-        artefact_name=artefact_name,
-        classifier=classifier
-    )
-
-    mock_filter_list.assert_called_once_with(
-        list_to_filter=child_artefacts,
-        list_filter=None,
-        content_retrieval_strategy=ArtefactLister.artefact_content_retrieval,
-        file_path_retrieval=ArtefactLister.artefact_path_retrieval,
-        tag_retrieval=ArtefactLister.artefact_tags_retrieval
-    )
-
-    mock_classifier_instance.print_classified_files.assert_called_once_with(
-        files_by_classifier=filtered_child_artefacts
-    )
-
-
-@pytest.mark.parametrize("classifier, artefact_name, classified_artefacts, expected_suggestions", [
-    ("classifier1", "missing_artefact", {"classifier1": []}, True),
-])
-@patch('ara_cli.artefact_lister.FileClassifier')
-@patch('ara_cli.artefact_lister.suggest_close_name_matches')
-@patch('ara_cli.artefact_lister.ArtefactReader')
-def test_list_data_no_match(mock_artefact_reader, mock_suggest, mock_file_classifier, classifier, artefact_name, classified_artefacts, expected_suggestions, artefact_lister):
-    mock_classifier_instance = mock_file_classifier.return_value
-    mock_classifier_instance.classify_files = MagicMock(return_value=classified_artefacts)
-
-    artefact_lister.list_data(classifier, artefact_name)
-
-    if expected_suggestions:
-        mock_suggest.assert_called_once_with(artefact_name, [])
-    else:
-        mock_suggest.assert_not_called()
-
-@pytest.mark.parametrize("classifier, artefact_name, content, file_path, file_exists", [
-    ("classifier2", "artefact1", "some content", "path/to/artefact", True),
-    ("classifier2", "artefact1", "some content", "path/to/artefact", False)
-])
-@patch('ara_cli.artefact_lister.FileClassifier')
-@patch('ara_cli.artefact_lister.ArtefactReader')
-@patch('ara_cli.artefact_lister.Artefact')
-@patch('ara_cli.artefact_lister.os.path')
-@patch('ara_cli.artefact_lister.list_files_in_directory')
-def test_list_data_with_match(mock_list_files, mock_os_path, mock_artefact, mock_artefact_reader, mock_file_classifier, classifier, artefact_name, content, file_path, file_exists, artefact_lister):
-    mock_classifier_instance = mock_file_classifier.return_value
-    mock_classifier_instance.classify_files = MagicMock(return_value={classifier: [MagicMock(file_name=artefact_name)]})
-
-    mock_artefact_reader.read_artefact = MagicMock(return_value=(content, file_path))
-
-    artefact_instance = MagicMock(name=artefact_name)
-    mock_artefact.from_content = MagicMock(return_value=artefact_instance)
-
-    mock_os_path.splitext = MagicMock(return_value=(file_path, '.ext'))
-    mock_os_path.exists = MagicMock(return_value=file_exists)
-
-    artefact_lister.list_data(classifier, artefact_name)
-
-    if file_exists:
-        mock_list_files.assert_called_once_with(file_path + '.data', None)
-    else:
-        mock_list_files.assert_not_called()
+
+        # Verify print_classified_files was called with filtered results
+        mock_classifier_instance.print_classified_files.assert_called_once_with(
+            filtered_artefacts
+        )
+
+
+@pytest.mark.parametrize(
+    "classifier, artefact_name, list_filter, classified_artefacts, artefact_info, matching_artefacts, value_chain_artefacts, filtered_artefacts",
+    [
+        # Case 1: Artefact found, with value chain, no filter
+        (
+            "epic",
+            "Epic1",
+            None,
+            {"epic": [{"title": "Epic1"}, {"title": "Epic2"}]},
+            [{"title": "Epic1"}, {"title": "Epic2"}],
+            [{"title": "Epic1"}],
+            {"epic": ["Epic1"], "userstory": ["Story1", "Story2"]},
+            {"epic": ["Epic1"], "userstory": ["Story1", "Story2"]},
+        ),
+        # Case 2: Artefact found, with value chain, with filter
+        (
+            "epic",
+            "Epic1",
+            ListFilter(include_tags=["tag1"]),
+            {"epic": [{"title": "Epic1"}, {"title": "Epic2"}]},
+            [{"title": "Epic1"}, {"title": "Epic2"}],
+            [{"title": "Epic1"}],
+            {"epic": ["Epic1"], "userstory": ["Story1", "Story2"]},
+            {"epic": ["Epic1"], "userstory": ["Story1"]},  # Filtered result
+        ),
+        # Case 3: Artefact not found
+        (
+            "epic",
+            "NonExistentEpic",
+            None,
+            {"epic": [{"title": "Epic1"}, {"title": "Epic2"}]},
+            [{"title": "Epic1"}, {"title": "Epic2"}],
+            [],
+            {"epic": []},
+            {"epic": []},
+        ),
+        # Case 4: Empty artefact list
+        (
+            "epic",
+            "Epic1",
+            None,
+            {"epic": []},
+            [],
+            [],
+            {"epic": []},
+            {"epic": []},
+        ),
+    ],
+)
+def test_list_branch(
+    artefact_lister,
+    classifier,
+    artefact_name,
+    list_filter,
+    classified_artefacts,
+    artefact_info,
+    matching_artefacts,
+    value_chain_artefacts,
+    filtered_artefacts,
+):
+    # Setup mocks
+    with patch("ara_cli.artefact_lister.FileClassifier") as mock_file_classifier, patch(
+        "ara_cli.artefact_lister.suggest_close_name_matches"
+    ) as mock_suggest, patch(
+        "ara_cli.artefact_lister.ArtefactReader"
+    ) as mock_artefact_reader, patch(
+        "ara_cli.artefact_lister.os"
+    ) as mock_os:
+
+        # Configure mock FileClassifier
+        mock_classifier_instance = MagicMock()
+        mock_file_classifier.return_value = mock_classifier_instance
+        mock_classifier_instance.classify_files_new.return_value = classified_artefacts
+
+        # Mock step_through_value_chain to modify the provided dictionary
+        def mock_step_through(artefact_name, classifier, artefacts_by_classifier):
+            # Replace the artefacts_by_classifier with our test data
+            for k, v in value_chain_artefacts.items():
+                artefacts_by_classifier[k] = v
+
+        mock_artefact_reader.step_through_value_chain.side_effect = mock_step_through
+
+        # Mock filter_artefacts method
+        artefact_lister.filter_artefacts = MagicMock(return_value=filtered_artefacts)
+
+        # Call the method under test
+        artefact_lister.list_branch(classifier, artefact_name, list_filter)
+
+        # Verify interactions
+        mock_file_classifier.assert_called_once_with(mock_os)
+        mock_classifier_instance.classify_files_new.assert_called_once()
+
+        # Check if suggestions were made for non-existent artefacts
+        if not matching_artefacts:
+            mock_suggest.assert_called_once_with(
+                artefact_name, [info["title"] for info in artefact_info]
+            )
+        else:
+            mock_suggest.assert_not_called()
+
+        # Verify ArtefactReader.step_through_value_chain was called with correct parameters
+        mock_artefact_reader.step_through_value_chain.assert_called_once()
+        call_args = mock_artefact_reader.step_through_value_chain.call_args[1]
+        assert call_args["artefact_name"] == artefact_name
+        assert call_args["classifier"] == classifier
+        assert classifier in call_args["artefacts_by_classifier"]
+
+        # Verify filter_artefacts was called with correct parameters
+        # The exact contents will have been modified by the mock_step_through function
+        artefact_lister.filter_artefacts.assert_called_once()
+        filter_args = artefact_lister.filter_artefacts.call_args[0]
+        assert filter_args[1] == list_filter
+
+        # Verify print_classified_files was called with filtered results
+        mock_classifier_instance.print_classified_files.assert_called_once_with(
+            filtered_artefacts
+        )
+
+
+@pytest.mark.parametrize(
+    "classifier, artefact_name, list_filter, classified_artefacts, artefact_paths, matching_paths, data_dir_exists",
+    [
+        # Case 1: Artefact found, data directory exists
+        (
+            "epic",
+            "Epic1",
+            None,
+            {"epic": ["path/to/Epic1.epic", "path/to/Epic2.epic"]},
+            ["path/to/Epic1.epic", "path/to/Epic2.epic"],
+            ["path/to/Epic1.epic"],
+            True
+        ),
+        # Case 2: Artefact found, data directory exists, with filter
+        (
+            "userstory",
+            "Story1",
+            ListFilter(include_tags=["tag1"]),
+            {"userstory": ["path/to/Story1.userstory", "path/to/Story2.userstory"]},
+            ["path/to/Story1.userstory", "path/to/Story2.userstory"],
+            ["path/to/Story1.userstory"],
+            True
+        ),
+        # Case 3: Artefact found, data directory doesn't exist
+        (
+            "epic",
+            "Epic1",
+            None,
+            {"epic": ["path/to/Epic1.epic", "path/to/Epic2.epic"]},
+            ["path/to/Epic1.epic", "path/to/Epic2.epic"],
+            ["path/to/Epic1.epic"],
+            False
+        ),
+        # Case 4: Artefact not found
+        (
+            "epic",
+            "NonExistentEpic",
+            None,
+            {"epic": ["path/to/Epic1.epic", "path/to/Epic2.epic"]},
+            ["path/to/Epic1.epic", "path/to/Epic2.epic"],
+            [],
+            False
+        ),
+        # Case 5: Empty artefact list
+        (
+            "epic",
+            "Epic1",
+            None,
+            {"epic": []},
+            [],
+            [],
+            False
+        ),
+    ],
+)
+def test_list_data(
+    artefact_lister,
+    classifier,
+    artefact_name,
+    list_filter,
+    classified_artefacts,
+    artefact_paths,
+    matching_paths,
+    data_dir_exists,
+):
+    # Setup mocks
+    with patch("ara_cli.artefact_lister.FileClassifier") as mock_file_classifier, \
+         patch("ara_cli.artefact_lister.suggest_close_name_matches") as mock_suggest, \
+         patch("ara_cli.artefact_lister.os") as mock_os, \
+         patch("ara_cli.artefact_lister.list_files_in_directory") as mock_list_files:
+
+        # Configure mock FileClassifier
+        mock_classifier_instance = MagicMock()
+        mock_file_classifier.return_value = mock_classifier_instance
+        mock_classifier_instance.classify_files.return_value = classified_artefacts
+
+        # Configure os path mocks
+        mock_os.path.basename.side_effect = lambda p: p.split('/')[-1]
+        mock_os.path.splitext.side_effect = lambda p: (p.rsplit('.', 1)[0], '.' + p.rsplit('.', 1)[1])
+        mock_os.path.exists.return_value = data_dir_exists
+
+        # Call the method under test
+        artefact_lister.list_data(classifier, artefact_name, list_filter)
+
+        # Verify interactions
+        mock_file_classifier.assert_called_once_with(mock_os)
+        mock_classifier_instance.classify_files.assert_called_once()
+
+        # Check if suggestions were made for non-existent artefacts
+        if not matching_paths:
+            mock_suggest.assert_called_once()
+        else:
+            # Verify path handling for found artefact
+            expected_data_dir = matching_paths[0].rsplit('.', 1)[0] + '.data'
+            mock_os.path.exists.assert_called_with(expected_data_dir)
+            
+            # Verify list_files_in_directory was called if data dir exists
+            if data_dir_exists:
+                mock_list_files.assert_called_once_with(expected_data_dir, list_filter)
+            else:
+                mock_list_files.assert_not_called()