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

ara_cli/tests/test_artefact_reader.py

@@ -3,22 +3,21 @@ from unittest.mock import patch, mock_open, Mock
 from ara_cli.artefact_reader import ArtefactReader
 from ara_cli.artefact import Artefact
 
-
-@pytest.mark.parametrize("artefact_name, classifier, is_valid, file_exists, expected_output", [
-    ("artefact1", "valid_classifier", True, True, ("file content", "/valid_classifier/artefact1.valid_classifier")),
-    ("artefact2", "invalid_classifier", False, True, None),
-    ("artefact3", "valid_classifier", True, False, None),
+@pytest.mark.parametrize("artefact_name, classifier, is_valid, file_paths, expected_output, should_suggest", [
+    ("artefact1", "example", True, ["/example/artefact1.example"], ("file content", "/example/artefact1.example"), False),
+    ("artefact2", "invalid_classifier", False, ["/invalid_classifier/artefact2.invalid_classifier"], None, False),
+    ("artefact3", "example", True, [], None, True),
 ])
-def test_read_artefact(artefact_name, classifier, is_valid, file_exists, expected_output):
+def test_read_artefact(artefact_name, classifier, is_valid, file_paths, expected_output, should_suggest):
     original_directory = "/original/directory"
 
     with patch('os.getcwd', return_value=original_directory), \
          patch('os.chdir') as mock_chdir, \
          patch('ara_cli.directory_navigator.DirectoryNavigator.navigate_to_target'), \
          patch('ara_cli.classifier.Classifier.is_valid_classifier', return_value=is_valid), \
-         patch('ara_cli.classifier.Classifier.get_sub_directory', return_value=f"/{classifier}"), \
-         patch('os.path.exists', return_value=file_exists), \
-         patch('builtins.open', mock_open(read_data="file content")) as mock_file:
+         patch('ara_cli.file_classifier.FileClassifier.classify_files', return_value={classifier: file_paths}), \
+         patch('builtins.open', mock_open(read_data="file content")) as mock_file, \
+         patch('ara_cli.artefact_fuzzy_search.suggest_close_name_matches') as mock_suggest:
 
         if expected_output is None:
             expected_content, expected_file_path = None, None
@@ -36,50 +35,23 @@ def test_read_artefact(artefact_name, classifier, is_valid, file_exists, expecte
 
         if not is_valid:
             mock_file.assert_not_called()
-        elif not file_exists:
+            mock_suggest.assert_not_called()  # Suggestion would not be called for invalid classifier
+        elif not file_paths:
             mock_file.assert_not_called()
+            if not should_suggest:
+                mock_suggest.assert_not_called()
         else:
             mock_file.assert_called_once_with(expected_file_path, 'r')
-
+            mock_suggest.assert_not_called()  # Suggestion should not be called if a valid artefact is found
 
 @pytest.mark.parametrize("artefact_content, artefact_titles, expected_output", [
-    ("Contributes to: parent_name SomeTitle", ["SomeTitle"], ("parent_name", "SomeTitle")),
-    ("Contributes to parent_name SomeTitle", ["SomeTitle"], ("parent_name", "SomeTitle")),
-    ("Contributes to : parent_name AnotherTitle", ["SomeTitle", "AnotherTitle"], ("parent_name", "AnotherTitle")),
-    ("No contribution information here.", ["SomeTitle"], (None, None)),
-    ("Contributes to : parent_name NotListedTitle", ["SomeTitle"], (None, None)),
+    ("Contributes to: parent_name Example", ["Example"], ("parent_name", "Example")),
+    ("Contributes to parent_name Example", ["Example"], ("parent_name", "Example")),
+    ("Contributes to : parent_name Feature", ["Example", "Feature"], ("parent_name", "Feature")),
+    ("No contribution information here.", ["Example"], (None, None)),
+    ("Contributes to : parent_name NotListedTitle", ["Example"], (None, None)),
 ])
 def test_extract_parent_tree(artefact_content, artefact_titles, expected_output):
     with patch('ara_cli.classifier.Classifier.artefact_titles', return_value=artefact_titles):
         parent_name, parent_type = ArtefactReader.extract_parent_tree(artefact_content)
         assert (parent_name, parent_type) == expected_output
-
-
-@pytest.mark.parametrize("artefact_name, classifier, artefact_content, artefact_parent, expected_calls", [
-    ("artefact1", "classifier1", "content1", None, [("content1",)]),
-    ("artefact2", "classifier2", "content2", Mock(name="parent_artefact", classifier="parent_classifier"), 
-     [("content2",)]),
-    ("artefact3", "classifier3", "content3", None, [("content3",)]),
-])
-def test_step_through_value_chain(artefact_name, classifier, artefact_content, artefact_parent, expected_calls):
-    artefact_mock = Mock(spec=Artefact)
-    artefact_mock.name = artefact_name
-    artefact_mock.parent = artefact_parent
-
-    artefact_by_classifier = {}
-
-    with patch('ara_cli.artefact_reader.ArtefactReader.read_artefact', return_value=(artefact_content, "file_path")), \
-         patch('ara_cli.artefact.Artefact.from_content', return_value=artefact_mock) as mock_from_content:
-
-        ArtefactReader.step_through_value_chain(artefact_name, classifier, artefact_by_classifier)
-
-        # Check if artefact was added to the artefacts_by_classifier
-        assert artefact_mock in artefact_by_classifier[classifier]
-
-        # Check if the recursive calls are made correctly
-        for call_args in expected_calls:
-            mock_from_content.assert_any_call(*call_args)
-
-        # Ensure no duplicate artefacts are added
-        ArtefactReader.step_through_value_chain(artefact_name, classifier, artefact_by_classifier)
-        assert len(artefact_by_classifier[classifier]) == 1

ara_cli/tests/test_artefact_scan.py

@@ -0,0 +1,126 @@
+import pytest
+from unittest.mock import patch, MagicMock, mock_open, call
+from ara_cli.artefact_scan import check_file, find_invalid_files, show_results
+from pydantic import ValidationError
+
+
+def test_check_file_valid():
+    mock_artefact_class = MagicMock()
+    mock_artefact_class.deserialize.return_value = None
+
+    with patch("builtins.open", mock_open(read_data="valid content")):
+        is_valid, reason = check_file("dummy_path", mock_artefact_class)
+        assert is_valid is True
+        assert reason is None
+
+
+def test_check_file_value_error():
+    mock_artefact_class = MagicMock()
+    mock_artefact_class.deserialize.side_effect = ValueError("Value error")
+
+    with patch("builtins.open", mock_open(read_data="invalid content")):
+        is_valid, reason = check_file("dummy_path", mock_artefact_class)
+        assert is_valid is False
+        assert "Value error" in reason
+
+
+def test_check_file_assertion_error():
+    mock_artefact_class = MagicMock()
+    mock_artefact_class.deserialize.side_effect = AssertionError(
+        "Assertion error")
+
+    with patch("builtins.open", mock_open(read_data="invalid content")):
+        is_valid, reason = check_file("dummy_path", mock_artefact_class)
+        assert is_valid is False
+        assert "Assertion error" in reason
+
+
+def test_check_file_os_error():
+    mock_artefact_class = MagicMock()
+
+    with patch("builtins.open", side_effect=OSError("File not found")):
+        is_valid, reason = check_file("dummy_path", mock_artefact_class)
+        assert is_valid is False
+        assert "File error: File not found" in reason
+
+
+def test_check_file_unexpected_error():
+    mock_artefact_class = MagicMock()
+    mock_artefact_class.deserialize.side_effect = Exception("Unexpected error")
+
+    with patch("builtins.open", mock_open(read_data="content")):
+        is_valid, reason = check_file("dummy_path", mock_artefact_class)
+        assert is_valid is False
+        assert "Unexpected error: Exception('Unexpected error')" in reason
+
+# Tests for find_invalid_files
+
+
+def test_find_invalid_files():
+    mock_artefact_class = MagicMock()
+    with patch("ara_cli.artefact_models.artefact_mapping.artefact_type_mapping", {"test_classifier": mock_artefact_class}):
+        artefact_files = {
+            "test_classifier": [{"file_path": "file1.txt"}, {"file_path": "file2.txt"}, {"file_path": "templates/file3.txt"}]
+        }
+
+        with patch("ara_cli.artefact_scan.check_file") as mock_check_file:
+            mock_check_file.side_effect = [
+                (True, None),           # file1.txt
+                (False, "Invalid content")  # file2.txt
+            ]
+
+            invalid_files = find_invalid_files(
+                artefact_files, "test_classifier")
+            assert len(invalid_files) == 1
+            assert invalid_files[0] == ("file2.txt", "Invalid content")
+            mock_check_file.assert_has_calls([
+                call("file1.txt", mock_artefact_class),
+                call("file2.txt", mock_artefact_class)
+            ], any_order=False)
+
+# Tests for show_results
+
+
+def test_show_results_no_issues(capsys):
+    invalid_artefacts = {}
+    with patch("builtins.open", mock_open()) as m:
+        show_results(invalid_artefacts)
+        captured = capsys.readouterr()
+        assert captured.out == "All files are good!\n"
+        m.assert_called_once_with("incompatible_artefacts_report.md", "w")
+        handle = m()
+        handle.write.assert_has_calls([
+            call("# Artefact Check Report\n\n"),
+            call("No problems found.\n")
+        ], any_order=False)
+
+
+def test_show_results_with_issues(capsys):
+    invalid_artefacts = {
+        "classifier1": [("file1.txt", "reason1"), ("file2.txt", "reason2")],
+        "classifier2": [("file3.txt", "reason3")]
+    }
+    with patch("builtins.open", mock_open()) as m:
+        show_results(invalid_artefacts)
+        captured = capsys.readouterr()
+        expected_output = (
+            "\nIncompatible classifier1 Files:\n"
+            "\t- file1.txt\n"
+            "\t- file2.txt\n"
+            "\nIncompatible classifier2 Files:\n"
+            "\t- file3.txt\n"
+        )
+        assert captured.out == expected_output
+        m.assert_called_once_with("incompatible_artefacts_report.md", "w")
+        handle = m()
+        expected_writes = [
+            call("# Artefact Check Report\n\n"),
+            call("## classifier1\n"),
+            call("- `file1.txt`: reason1\n"),
+            call("- `file2.txt`: reason2\n"),
+            call("\n"),
+            call("## classifier2\n"),
+            call("- `file3.txt`: reason3\n"),
+            call("\n")
+        ]
+        handle.write.assert_has_calls(expected_writes, any_order=False)

ara_cli/tests/test_file_classifier.py

@@ -2,7 +2,8 @@ import pytest
 from unittest.mock import MagicMock, patch, mock_open, call
 from ara_cli.file_classifier import FileClassifier
 from ara_cli.classifier import Classifier
-from ara_cli.artefact import Artefact
+from ara_cli.artefact_models.artefact_load import artefact_from_content
+from ara_cli.artefact_models.artefact_load import artefact_from_content
 
 
 @pytest.fixture
@@ -22,12 +23,6 @@ def mock_get_artefact_title():
         yield
 
 
-@pytest.fixture
-def mock_artefact():
-    with patch.object(Artefact, 'from_content', side_effect=lambda content: Artefact(classifier='', name='', _file_path='')):
-        yield
-
-
 def test_file_classifier_init(mock_file_system):
     classifier = FileClassifier(mock_file_system)
     assert classifier.file_system == mock_file_system
@@ -40,7 +35,10 @@ def test_read_file_content(mock_file_system):
 
     with patch("builtins.open", mock_open(read_data=test_file_content)) as mock_file:
         content = classifier.read_file_content(test_file_path)
-        mock_file.assert_called_once_with(test_file_path, 'r', encoding='utf-8')
+        mock_file.assert_called_once_with(
+            test_file_path, 'r', encoding='utf-8')
+        mock_file.assert_called_once_with(
+            test_file_path, 'r', encoding='utf-8')
         assert content == test_file_content
 
 
@@ -74,16 +72,25 @@ def test_read_file_with_fallback(mock_file_system):
 
     with patch("builtins.open", mock_open(read_data=utf8_content)) as mock_file:
         content = classifier.read_file_with_fallback(test_file_path)
-        mock_file.assert_called_once_with(test_file_path, 'r', encoding='utf-8')
+        mock_file.assert_called_once_with(
+            test_file_path, 'r', encoding='utf-8')
+        mock_file.assert_called_once_with(
+            test_file_path, 'r', encoding='utf-8')
         assert content == utf8_content
 
     with patch("builtins.open", mock_open(read_data=utf8_content)) as mock_file:
-        mock_file.side_effect = [UnicodeDecodeError("mock", b"", 0, 1, "reason"), mock_open(read_data=latin1_content).return_value]
+        mock_file.side_effect = [UnicodeDecodeError(
+            "mock", b"", 0, 1, "reason"), mock_open(read_data=latin1_content).return_value]
+        mock_file.side_effect = [UnicodeDecodeError(
+            "mock", b"", 0, 1, "reason"), mock_open(read_data=latin1_content).return_value]
         content = classifier.read_file_with_fallback(test_file_path)
         assert content == latin1_content
 
     with patch("builtins.open", mock_open(read_data=utf8_content)) as mock_file:
-        mock_file.side_effect = [UnicodeDecodeError("mock", b"", 0, 1, "reason"), UnicodeDecodeError("mock", b"", 0, 1, "reason")]
+        mock_file.side_effect = [UnicodeDecodeError(
+            "mock", b"", 0, 1, "reason"), UnicodeDecodeError("mock", b"", 0, 1, "reason")]
+        mock_file.side_effect = [UnicodeDecodeError(
+            "mock", b"", 0, 1, "reason"), UnicodeDecodeError("mock", b"", 0, 1, "reason")]
         content = classifier.read_file_with_fallback(test_file_path)
         assert content is None
 
@@ -94,14 +101,23 @@ def test_file_contains_tags(mock_file_system):
     file_content = "tag1 tag2 tag3"
 
     with patch.object(classifier, 'read_file_with_fallback', return_value=file_content):
-        result = classifier.file_contains_tags(test_file_path, ['tag1', 'tag2'])
+        result = classifier.file_contains_tags(
+            test_file_path, ['tag1', 'tag2'])
+        result = classifier.file_contains_tags(
+            test_file_path, ['tag1', 'tag2'])
         assert result is True
 
-        result = classifier.file_contains_tags(test_file_path, ['tag1', 'tag4'])
+        result = classifier.file_contains_tags(
+            test_file_path, ['tag1', 'tag4'])
+        result = classifier.file_contains_tags(
+            test_file_path, ['tag1', 'tag4'])
         assert result is False
 
         with patch.object(classifier, 'read_file_with_fallback', return_value=None):
-            result = classifier.file_contains_tags(test_file_path, ['tag1', 'tag2'])
+            result = classifier.file_contains_tags(
+                test_file_path, ['tag1', 'tag2'])
+            result = classifier.file_contains_tags(
+                test_file_path, ['tag1', 'tag2'])
             assert result is False
 
 
@@ -110,7 +126,7 @@ def test_classify_file(mock_file_system, mock_classifier):
     test_file_path = "test_file.py"
 
     with patch.object(classifier, 'is_binary_file', return_value=False), \
-         patch.object(classifier, 'file_contains_tags', return_value=True):
+            patch.object(classifier, 'file_contains_tags', return_value=True):
         result = classifier.classify_file(test_file_path, tags=['tag1'])
         assert result == 'py'
 
@@ -124,7 +140,10 @@ def test_classify_file(mock_file_system, mock_classifier):
 
 
 def test_classify_files_skips_binary_files(mock_file_system, mock_classifier):
-    mock_file_system.walk.return_value = [('.', [], ['file1.py', 'file2.txt', 'file3.bin'])]
+    mock_file_system.walk.return_value = [
+        ('.', [], ['file1.py', 'file2.txt', 'file3.bin'])]
+    mock_file_system.walk.return_value = [
+        ('.', [], ['file1.py', 'file2.txt', 'file3.bin'])]
     mock_file_system.path.join.side_effect = lambda root, file: f"{root}/{file}"
 
     classifier = FileClassifier(mock_file_system)
@@ -145,7 +164,7 @@ def test_classify_file_no_match(mock_file_system, mock_classifier):
     test_file_path = "test_file.unknown"
 
     with patch.object(classifier, 'is_binary_file', return_value=False), \
-         patch.object(classifier, 'file_contains_tags', return_value=True):
+            patch.object(classifier, 'file_contains_tags', return_value=True):
         result = classifier.classify_file(test_file_path, tags=['tag1'])
         assert result is None
 
@@ -154,7 +173,7 @@ def test_classify_file_no_match(mock_file_system, mock_classifier):
     (
         [('.', [], ['file1.py', 'file2.txt', 'file3.bin'])],
         ['py', 'txt', 'bin'],
-        {'py': ['./file1.py'], 'txt': ['./file2.txt'], 'bin': ['./file3.bin']}
+        {'py': [{'file_path': './file1.py', 'title': 'file1'}], 'txt': [{'file_path': './file2.txt', 'title': 'file2'}], 'bin': [{'file_path': './file3.bin', 'title': 'file3'}]}
     ),
     (
         [('.', [], [])],
@@ -164,12 +183,12 @@ def test_classify_file_no_match(mock_file_system, mock_classifier):
     (
         [('.', [], ['file1.py', 'file2.unknown'])],
         ['py', None],
-        {'py': ['./file1.py'], 'txt': [], 'bin': []}
+        {'py': [{'file_path': './file1.py', 'title': 'file1'}], 'txt': [], 'bin': []}
     ),
     (
         [('.', [], ['file1.py', 'file2.txt', 'file3.unknown', 'file4.bin'])],
         ['py', 'txt', None, 'bin'],
-        {'py': ['./file1.py'], 'txt': ['./file2.txt'], 'bin': ['./file4.bin']}
+        {'py': [{'file_path': './file1.py', 'title': 'file1'}], 'txt': [{'file_path': './file2.txt', 'title': 'file2'}], 'bin': [{'file_path': './file4.bin', 'title': 'file4'}]}
     ),
 ])
 def test_classify_files(mock_file_system, mock_classifier, walk_return_value, classify_file_side_effect, expected_result):
@@ -187,25 +206,45 @@ def test_classify_files(mock_file_system, mock_classifier, walk_return_value, cl
 @pytest.mark.parametrize("files_by_classifier, expected_output", [
     (
         {'py': [MagicMock(file_path='file1.py')], 'txt': [], 'bin': []},
-        "PY Title files:\n  - file1.py\n\n"
+        "PY Title files:\n  - ./file1.py\n\n"
     ),
     (
-        {'py': [], 'txt': [MagicMock(file_path='file2.txt')], 'bin': []},
-        "TXT Title files:\n  - file2.txt\n\n"
+        {'txt': [MagicMock(file_path='file2.txt')], 'py': [], 'bin': []},
+        "TXT Title files:\n  - ./file2.txt\n\n"
     ),
     (
-        {'py': [], 'txt': [], 'bin': [MagicMock(file_path='file3.bin')]},
-        "BIN Title files:\n  - file3.bin\n\n"
+        {'bin': [MagicMock(file_path='file3.bin')], 'py': [], 'txt': []},
+        "BIN Title files:\n  - ./file3.bin\n\n"
     ),
     (
-        {'py': [MagicMock(file_path='file1.py')], 'txt': [MagicMock(file_path='file2.txt')], 'bin': []},
-        "PY Title files:\n  - file1.py\n\nTXT Title files:\n  - file2.txt\n\n"
+        {'py': [MagicMock(file_path='file1.py')], 'txt': [
+            MagicMock(file_path='file2.txt')], 'bin': []},
+        "PY Title files:\n  - ./file1.py\n\nTXT Title files:\n  - ./file2.txt\n\n"
     ),
 ])
 def test_print_classified_files(mock_file_system, mock_classifier, mock_get_artefact_title, files_by_classifier, expected_output, capsys):
     classifier = FileClassifier(mock_file_system)
-
     classifier.print_classified_files(files_by_classifier)
-
     captured = capsys.readouterr()
     assert captured.out == expected_output
+
+
+def test_find_closest_artefact_name_match(mock_file_system):
+    classifier = FileClassifier(mock_file_system)
+    classifier.classify_files = MagicMock(return_value={
+        'py': ['file1', 'file2'],
+        'txt': []
+    })
+
+    # Exact match
+    assert classifier.find_closest_artefact_name_match(
+        'file1', 'py') == 'file1'
+
+    # Fuzzy match
+    with patch('ara_cli.file_classifier.find_closest_name_match', return_value='file2') as mock_fuzzy:
+        assert classifier.find_closest_artefact_name_match(
+            'file3', 'py') == 'file2'
+        mock_fuzzy.assert_called_once_with('file3', ['file1', 'file2'])
+
+    # No match for classifier
+    assert classifier.find_closest_artefact_name_match('file1', 'txt') is None

ara_cli/tests/test_tag_extractor.py

@@ -1,64 +1,45 @@
 import pytest
-from unittest.mock import MagicMock, patch, mock_open
-from ara_cli.tag_extractor import TagExtractor
-from ara_cli.artefact_models.artefact_load import artefact_from_content
+from unittest.mock import MagicMock, patch
+from ara_cli.tag_extractor import TagExtractor  # Adjust the import based on your project structure
 
 @pytest.fixture
-def mock_file_system():
-    return MagicMock()
-
-@pytest.fixture
-def mock_directory_navigator():
-    with patch('ara_cli.template_manager.DirectoryNavigator') as MockNavigator:
-        yield MockNavigator
-
-@pytest.fixture
-def mock_file_classifier():
-    with patch('ara_cli.file_classifier.FileClassifier') as MockClassifier:
-        instance = MockClassifier.return_value
-        instance.classify_files_new.return_value = {
-            'py': ['file1.py'],
-            'txt': ['file2.txt'],
-            'bin': []
-        }
-        yield instance
-
-@pytest.fixture
-def mock_artefact_from_content():
-    with patch('ara_cli.tag_extractor.artefact_from_content') as mock_artefact:
-        def artefact_side_effect(content):
-            if "invalid" not in content:
-                mock_artefact_object = MagicMock()
-                mock_artefact_object.tags = ["tag1"]
-                mock_artefact_object.users = ["user1"]
-                mock_artefact_object.status = "status1"
-                return mock_artefact_object
-            else:
-                raise ValueError("Invalid content")
-
-        mock_artefact.side_effect = artefact_side_effect
-        yield mock_artefact
-
-def test_extract_tags(mock_file_system, mock_directory_navigator, mock_file_classifier, mock_artefact_from_content):
-    file_content_map = {
-        'file1.py': 'valid content for file1',
-        'file2.txt': 'invalid content for file2'
-    }
-
-    def mock_open_file(file, mode):
-        if mode == 'r':
-            return mock_open(read_data=file_content_map[file]).return_value
-        else:
-            raise ValueError("Unsupported mode")
-
-    with patch('builtins.open', mock_open_file):
-        tag_extractor = TagExtractor(file_system=mock_file_system)
-
-        # Test without navigating to target
-        tags = tag_extractor.extract_tags(navigate_to_target=False)
-        assert tags == ['status1', 'tag1', 'user_user1']
-
-        # Test with navigating to target
-        tags = tag_extractor.extract_tags(navigate_to_target=True)
-        mock_directory_navigator.return_value.navigate_to_target.assert_called_once()
-        assert tags == ['status1', 'tag1', 'user_user1']
+def artefact():
+    """Fixture to create a mock artefact object."""
+    class Artefact:
+        def __init__(self, tags, status, users):
+            self.tags = tags
+            self.status = status
+            self.users = users
+
+    return Artefact
+
+@pytest.mark.parametrize("navigate_to_target, artefact_data, expected_tags", [
+    (False, {'artefacts': [(
+        ['tag1', 'tag2'], 'status1', ['user1', 'user2']
+    )]}, ['status1', 'tag1', 'tag2', 'user_user1', 'user_user2']),
+    (True, {'artefacts': [(
+        ['tag3'], 'status2', ['user3']
+    )]}, ['status2', 'tag3', 'user_user3'])
+])
+@patch('ara_cli.template_manager.DirectoryNavigator')
+@patch('ara_cli.artefact_reader.ArtefactReader')
+def test_extract_tags(mock_artefact_reader, mock_directory_navigator, artefact, navigate_to_target, artefact_data, expected_tags):
+    # Mock the artefact reader to return artefact data
+    mock_artefact_reader.read_artefacts.return_value = {'key': [artefact(*data) for data in artefact_data['artefacts']]}
+
+    # Mock the directory navigator
+    mock_navigator_instance = mock_directory_navigator.return_value
+    mock_navigator_instance.navigate_to_target = MagicMock()
+
+    tag_extractor = TagExtractor()
+
+    # Run the extract_tags method
+    result = tag_extractor.extract_tags(navigate_to_target=navigate_to_target)
+
+    # Assertions
+    if navigate_to_target:
+        mock_navigator_instance.navigate_to_target.assert_called_once()
+    else:
+        mock_navigator_instance.navigate_to_target.assert_not_called()
+
+    assert result == expected_tags

ara_cli/version.py

@@ -1,2 +1,2 @@
 # version.py
-__version__ = "0.1.9.49"   # fith parameter like .0 for local install test purposes only. official numbers should be 4 digit numbers
+__version__ = "0.1.9.51"   # fith parameter like .0 for local install test purposes only. official numbers should be 4 digit numbers

{ara_cli-0.1.9.49.dist-info → ara_cli-0.1.9.51.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ara-cli
-Version: 0.1.9.49
+Version: 0.1.9.51
 Requires-Dist: litellm
 Requires-Dist: llama-index
 Requires-Dist: llama-index-llms-openai