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

ara_cli/tag_extractor.py

@@ -8,30 +8,20 @@ class TagExtractor:
 
     def extract_tags(self, navigate_to_target=False):
         from ara_cli.template_manager import DirectoryNavigator
-        from ara_cli.file_classifier import FileClassifier
+        from ara_cli.artefact_reader import ArtefactReader
 
         navigator = DirectoryNavigator()
         if navigate_to_target:
             navigator.navigate_to_target()
 
-        file_classifier = FileClassifier(self.file_system)
-        classified_files = file_classifier.classify_files_new()
+        artefacts = ArtefactReader.read_artefacts()
 
         unique_tags = set()
 
-        for artefacts in classified_files.values():
-            for artefact in artefacts:
-                with open(artefact, 'r') as file:
-                    artefact_content = file.read()
-                try:
-                    artefact_object = artefact_from_content(artefact_content)
-                except ValueError:
-                    continue
-                if not artefact_object:
-                    continue
-                status_list = ([artefact_object.status] if artefact_object.status is not None else [])
-                users_list = [f"user_{user}" for user in artefact_object.users]
-                tags = artefact_object.tags + users_list + status_list
+        for artefact_list in artefacts.values():
+            for artefact in artefact_list:
+                user_tags = [f"user_{tag}" for tag in artefact.users]
+                tags = [tag for tag in (artefact.tags + [artefact.status] + user_tags) if tag is not None]
                 unique_tags.update(tags)
 
         sorted_tags = sorted(unique_tags)

ara_cli/templates/specification_breakdown_files/template.concept.md

@@ -1,27 +1,25 @@
 # Title: <descriptive title of the architecture concept>
 
-- [Title: ](#title-)
-- [Decision for Architecture Design](#decision-for-architecture-design)
-  - [functional major decisions](#functional-major-decisions)
-  - [non functional major decisions](#non-functional-major-decisions)
-- [Component Diagram in plantuml](#component-diagram-in-plantuml)
-- [Deployment diagram in plantuml](#deployment-diagram-in-plantuml)
+# C4 Context Diagram in mermaid
+```
 
-# Decision for Architecture Design
-## functional major decisions
-<list of major functional decisions of the concept>
+```
+Description: <description of the purpose and the value of the components of the diagram>
 
-## non functional major decisions
-<list of major non functional decisions of the concept>
+## C4 Container Diagram in mermaid
+```
+
+```
+Description: <description of the purpose and the value of the components of the diagram>
 
-# Component Diagram in plantuml
+### C4 Component Diagram in mermaid
 ```
 
 ```
 Description: <description of the purpose and the value of the components of the diagram>
 
-# Deployment diagram in plantuml
+#### C4 Code Diagram in mermaid
 ```
 
 ```
-Description: <description of the purpose and the value of the building blocks of the diagram>
+Description: <description of the purpose and the value of the components of the diagram>

ara_cli/tests/test_ara_command_action.py

@@ -1,5 +1,5 @@
 import pytest
-from unittest.mock import patch, MagicMock, call
+from unittest.mock import patch, MagicMock, call, mock_open
 from ara_cli.ara_command_action import (
     check_validity,
     create_action,
@@ -10,7 +10,8 @@ from ara_cli.ara_command_action import (
     read_user_action,
     set_status_action,
     set_user_action,
-    classifier_directory_action
+    classifier_directory_action,
+    scan_action
 )
 
 
@@ -100,7 +101,8 @@ def mock_suggest_close_name_matches():
 
 @pytest.mark.parametrize(
     "condition, error_message",
-    [(True, "This should not be printed"), (False, "This is a test error message")],
+    [(True, "This should not be printed"),
+     (False, "This is a test error message")],
 )
 def test_check_validity(condition, error_message):
     with patch("sys.exit") as mock_exit, patch("builtins.print") as mock_print:
@@ -345,192 +347,259 @@ def test_list_action_creates_list_filter(
 
 
 @pytest.mark.parametrize(
-    "classifier, artefact_name, artefact_names, content, status, expected_output",
+    "classifier, artefact_name, artefact_exists, status, expected_output",
     [
         # Case when artefact_name is not found in artefact_names
-        ("test_classifier", "non_existent_artefact", ["artefact1", "artefact2"], None, None, None),
+        ("test_classifier", "non_existent_artefact", False, None, None),
         
         # Case when artefact_name is found but no status is available
-        ("test_classifier", "artefact1", ["artefact1", "artefact2"], "some_content", None, "No status found"),
+        ("test_classifier", "artefact1", True, None, "No status found"),
         
         # Case when artefact_name is found and status is available
-        ("test_classifier", "artefact2", ["artefact1", "artefact2"], "some_content", "Active", "Active"),
+        ("test_classifier", "artefact2", True, "Active", "Active"),
     ]
 )
-def test_read_status_action(classifier, artefact_name, artefact_names, content, status, expected_output):
+def test_read_status_action(classifier, artefact_name, artefact_exists, status, expected_output):
     args = MagicMock()
     args.classifier = classifier
     args.parameter = artefact_name
-    
+
     mock_artefact = MagicMock()
     mock_artefact.status = status
 
+    # Create mock artefact info
+    artefact_info_dicts = []
+    if artefact_exists:
+        artefact_info_dicts.append({
+            "title": artefact_name,
+            "file_path": f"/path/to/{artefact_name}.md"
+        })
+    
+    all_artefact_names = [info["title"] for info in artefact_info_dicts]
+
     with patch('ara_cli.file_classifier.FileClassifier') as MockFileClassifier, \
-         patch('ara_cli.artefact_reader.ArtefactReader') as MockArtefactReader, \
          patch('ara_cli.artefact_models.artefact_load.artefact_from_content') as mock_artefact_from_content, \
-         patch('ara_cli.ara_command_action.suggest_close_name_matches') as mock_suggest_close_name_matches:
+         patch('ara_cli.ara_command_action.suggest_close_name_matches') as mock_suggest_close_name_matches, \
+         patch('builtins.open', new_callable=MagicMock()) as mock_open, \
+         patch('builtins.print') as mock_print:
 
+        # Configure file classifier mock
         mock_classifier_instance = MockFileClassifier.return_value
-        mock_classifier_instance.classify_files.return_value = {classifier: [MagicMock(file_name=name) for name in artefact_names]}
-
-        MockArtefactReader.read_artefact.return_value = (content, "dummy/path")
+        mock_classifier_instance.classify_files_new.return_value = {classifier: artefact_info_dicts}
+        
+        # Configure file open mock
+        mock_file_handle = MagicMock()
+        mock_file_handle.__enter__.return_value.read.return_value = "mock file content"
+        mock_open.return_value = mock_file_handle
+        
+        # Configure artefact mock
         mock_artefact_from_content.return_value = mock_artefact
 
-        if expected_output:
-            with patch('builtins.print') as mock_print:
-                read_status_action(args)
-                mock_print.assert_called_once_with(expected_output)
+        # Call the function
+        read_status_action(args)
+
+        # Verify behavior
+        if not artefact_exists:
+            # Should suggest close matches when artefact not found
+            mock_suggest_close_name_matches.assert_called_once_with(artefact_name, all_artefact_names)
+            mock_open.assert_not_called()
         else:
-            read_status_action(args)
-            # Ensure the name suggestion is called when artefact_name is not found
-            if artefact_name not in artefact_names:
-                mock_suggest_close_name_matches.assert_called_once_with(artefact_name, artefact_names)
+            # Should open the file and read content
+            mock_open.assert_called_once()
+            mock_artefact_from_content.assert_called_once_with("mock file content")
+            
+            if status:
+                mock_print.assert_called_once_with(status)
+            else:
+                mock_print.assert_called_once_with("No status found")
 
 
-@pytest.mark.parametrize(
-    "classifier, artefact_name, artefact_names, content, user_tags, expected_output",
-    [
-        ("test_classifier", "non_existent_artefact", ["artefact1", "artefact2"], None, None, None),
-        ("test_classifier", "artefact1", ["artefact1", "artefact2"], "some_content", [], "No user found"),
-        ("test_classifier", "artefact2", ["artefact1", "artefact2"], "some_content", ["User1", "User2"],
-         " - User1\n - User2")
-    ]
-)
-def test_read_user_action(classifier, artefact_name, artefact_names, content, user_tags, expected_output):
-    args = MagicMock()
-    args.classifier = classifier
-    args.parameter = artefact_name
-    
-    mock_artefact = MagicMock()
-    mock_artefact.users = user_tags
+def read_user_action(args):
+    from ara_cli.artefact_models.artefact_load import artefact_from_content
+    from ara_cli.file_classifier import FileClassifier
 
-    with patch('ara_cli.file_classifier.FileClassifier') as MockFileClassifier, \
-         patch('ara_cli.artefact_reader.ArtefactReader') as MockArtefactReader, \
-         patch('ara_cli.artefact_models.artefact_load.artefact_from_content') as mock_artefact_from_content, \
-         patch('ara_cli.ara_command_action.suggest_close_name_matches') as mock_suggest_close_name_matches:
+    classifier = args.classifier
+    artefact_name = args.parameter
 
-        mock_classifier_instance = MockFileClassifier.return_value
-        mock_classifier_instance.classify_files.return_value = {classifier: [MagicMock(file_name=name) for name in artefact_names]}
+    file_classifier = FileClassifier(os)
+    artefact_info = file_classifier.classify_files_new()
+    artefact_info_dicts = artefact_info.get(classifier, [])
 
-        MockArtefactReader.read_artefact.return_value = (content, "dummy/path")
-        mock_artefact_from_content.return_value = mock_artefact
+    all_artefact_names = [artefact_info["title"] for artefact_info in artefact_info_dicts]
+    if artefact_name not in all_artefact_names:
+        suggest_close_name_matches(artefact_name, all_artefact_names)
+        return
 
-        if expected_output:
-            with patch('builtins.print') as mock_print:
-                read_user_action(args)
-                if expected_output == "No user found":
-                    mock_print.assert_called_once_with(expected_output)
-                else:
-                    # Check each line of output individually
-                    expected_calls = [call(f" - {user}") for user in user_tags]
-                    mock_print.assert_has_calls(expected_calls, any_order=False)
-        else:
-            read_user_action(args)
-            # Ensure the name suggestion is called when artefact_name is not found
-            if artefact_name not in artefact_names:
-                mock_suggest_close_name_matches.assert_called_once_with(artefact_name, artefact_names)
+    artefact_info = next(filter(
+        lambda x: x["title"] == artefact_name, artefact_info_dicts
+    ))
+
+    with open(artefact_info["file_path"], 'r') as file:
+        content = file.read()
+    artefact = artefact_from_content(content)
+
+    user_tags = artefact.users
+
+    if not user_tags:
+        print("No user found")
+        return
+    for tag in user_tags:
+        print(f" - {tag}")
 
 
 @pytest.mark.parametrize(
-    "classifier, artefact_name, artefact_names, new_status, content, expected_output, should_suggest",
+    "classifier, artefact_name, artefact_names, new_status, status_tags, content, expected_output, should_suggest",
     [
         # Case when artefact_name is not found in artefact_names
-        ("test_classifier", "non_existent_artefact", ["artefact1", "artefact2"], "to-do", None, None, True),
+        ("test_classifier", "non_existent_artefact", ["artefact1", "artefact2"], "to-do", ["to-do", "review", "done"], None, None, True),
 
         # Case when new_status is invalid
-        ("test_classifier", "artefact1", ["artefact1", "artefact2"], "invalid_status", "some_content", None, False),
+        ("test_classifier", "artefact1", ["artefact1", "artefact2"], "invalid_status", ["to-do", "review", "done"], "some_content", None, False),
 
         # Case when artefact_name is found and status is successfully changed
-        ("test_classifier", "artefact1", ["artefact1", "artefact2"], "review", "some_content", "Status of task 'artefact1' has been updated to 'review'.", False),
+        ("test_classifier", "artefact1", ["artefact1", "artefact2"], "review", ["to-do", "review", "done"], "some_content", 
+         "Status of task 'artefact1' has been updated to 'review'.", False),
         
         # Case when new_status has a leading '@'
-        ("test_classifier", "artefact1", ["artefact1", "artefact2"], "@done", "some_content", "Status of task 'artefact1' has been updated to 'done'.", False),
+        ("test_classifier", "artefact1", ["artefact1", "artefact2"], "@done", ["to-do", "review", "done"], "some_content", 
+         "Status of task 'artefact1' has been updated to 'done'.", False),
     ]
 )
-def test_set_status_action(classifier, artefact_name, artefact_names, new_status, content, expected_output, should_suggest):
+def test_set_status_action(classifier, artefact_name, artefact_names, new_status, status_tags, content, expected_output, should_suggest):
     args = MagicMock()
     args.classifier = classifier
     args.parameter = artefact_name
     args.new_status = new_status
 
+    # Create artefact info dictionaries for each artefact name
+    artefact_info_dicts = [
+        {"title": name, "file_path": f"/path/to/{name}.md"} 
+        for name in artefact_names
+    ]
+
     mock_artefact = MagicMock()
     mock_artefact.serialize.return_value = "serialized_content"
 
-    with patch('ara_cli.file_classifier.FileClassifier') as MockFileClassifier, \
-         patch('ara_cli.artefact_reader.ArtefactReader') as MockArtefactReader, \
+    with patch('ara_cli.artefact_models.artefact_model.ALLOWED_STATUS_VALUES', status_tags), \
+         patch('ara_cli.file_classifier.FileClassifier') as MockFileClassifier, \
          patch('ara_cli.artefact_models.artefact_load.artefact_from_content') as mock_artefact_from_content, \
          patch('ara_cli.ara_command_action.suggest_close_name_matches') as mock_suggest_close_name_matches, \
          patch('builtins.open', new_callable=MagicMock) as mock_open, \
          patch('ara_cli.ara_command_action.check_validity') as mock_check_validity:
 
+        # Configure mock file classifier
         mock_classifier_instance = MockFileClassifier.return_value
-        mock_classifier_instance.classify_files.return_value = {classifier: [MagicMock(file_name=name) for name in artefact_names]}
-
-        MockArtefactReader.read_artefact.return_value = (content, "dummy/path")
+        mock_classifier_instance.classify_files_new.return_value = {classifier: artefact_info_dicts}
+        
+        # Configure mock file handling
+        mock_file_handle = MagicMock()
+        mock_file_handle.__enter__.return_value.read.return_value = content
+        mock_open.return_value = mock_file_handle
+        
+        # Configure artefact loading
         mock_artefact_from_content.return_value = mock_artefact
 
+        # Run the function under test
         if expected_output:
             with patch('builtins.print') as mock_print:
                 set_status_action(args)
+                
+                # Verify the status was set on the artefact
+                assert mock_artefact.status == new_status.lstrip('@') if new_status.startswith('@') else new_status
+                
+                # Verify the file was opened for reading and writing
+                expected_file_path = next(info["file_path"] for info in artefact_info_dicts if info["title"] == artefact_name)
+                mock_open.assert_any_call(expected_file_path, 'r')
+                mock_open.assert_any_call(expected_file_path, 'w')
+                
+                # Verify the serialized content was written
+                mock_file_handle.__enter__.return_value.write.assert_called_once_with("serialized_content")
+                
+                # Verify the success message was printed
                 mock_print.assert_called_once_with(expected_output)
-                mock_open.assert_called_once_with("dummy/path", 'w')
         else:
             set_status_action(args)
             if should_suggest:
+                # Should suggest close matches when artefact not found
                 mock_suggest_close_name_matches.assert_called_once_with(artefact_name, artefact_names)
+                mock_artefact_from_content.assert_not_called()
             else:
-                mock_check_validity.assert_called_once()
+                # Should validate the status
+                mock_check_validity.assert_called_once_with(
+                    new_status.lstrip('@') if new_status.startswith('@') else new_status in status_tags, 
+                    "Invalid status provided. Please provide a valid status."
+                )
 
 
 @pytest.mark.parametrize(
-    "artefact_names, artefact_tags, new_user, expected_tags, expected_output",
+    "classifier, artefact_name, artefact_names, new_user, expected_output",
     [
-        (["valid_artefact"], ["user_jane_doe"], "john_doe", {"user_john_doe"}, "User of task 'valid_artefact' has been updated to 'john_doe'."),
-        (["valid_artefact"], ["user_jane_doe"], "@john_doe", {"user_john_doe"}, "User of task 'valid_artefact' has been updated to 'john_doe'."),
-        (["valid_artefact"], [], "john_doe", {"user_john_doe"}, "User of task 'valid_artefact' has been updated to 'john_doe'."),
-        ([], [], "john_doe", None, None),
+        # Normal case
+        ("test_classifier", "valid_artefact", ["valid_artefact"], "john_doe", "User of task 'valid_artefact' has been updated to 'john_doe'."),
+        # Case with @ prefix in user name
+        ("test_classifier", "valid_artefact", ["valid_artefact"], "@john_doe", "User of task 'valid_artefact' has been updated to 'john_doe'."),
+        # Case where artefact is not found
+        ("test_classifier", "invalid_artefact", ["valid_artefact"], "john_doe", None),
     ],
 )
 def test_set_user_action(
-    mock_file_classifier,
-    mock_artefact_reader,
-    mock_artefact,
-    mock_suggest_close_name_matches,
-    artefact_names,
-    artefact_tags,
-    new_user,
-    expected_tags,
-    expected_output,
+    classifier, artefact_name, artefact_names, new_user, expected_output
 ):
-    MockFileClassifier = mock_file_classifier
-    MockArtefactReader = mock_artefact_reader
-    MockArtefact = mock_artefact
-
     args = MagicMock()
-    args.classifier = "test_classifier"
-    args.parameter = "valid_artefact"
+    args.classifier = classifier
+    args.parameter = artefact_name
     args.new_user = new_user
 
-    instance_file_classifier = MockFileClassifier.return_value
-    instance_file_classifier.classify_files.return_value = {
-        "test_classifier": [MagicMock(file_name=name) for name in artefact_names]
-    }
-
-    MockArtefactReader.read_artefact.return_value = ("content", "file_path")
+    # Create artefact info dictionaries for each artefact name
+    artefact_info_dicts = [
+        {"title": name, "file_path": f"/path/to/{name}.md"} 
+        for name in artefact_names
+    ]
+    
+    mock_artefact = MagicMock()
+    mock_artefact.serialize.return_value = "serialized_content"
+    
+    mock_file_content = "mock file content"
 
-    instance_artefact = MockArtefact.from_content.return_value
-    instance_artefact.tags = artefact_tags
+    with patch('ara_cli.file_classifier.FileClassifier') as MockFileClassifier, \
+         patch('ara_cli.artefact_models.artefact_load.artefact_from_content') as mock_artefact_from_content, \
+         patch('ara_cli.ara_command_action.suggest_close_name_matches') as mock_suggest_close_name_matches, \
+         patch('builtins.open', new_callable=MagicMock()) as mock_open, \
+         patch('builtins.print') as mock_print:
+        
+        # Configure mocks
+        mock_file_classifier_instance = MockFileClassifier.return_value
+        mock_file_classifier_instance.classify_files_new.return_value = {classifier: artefact_info_dicts}
+        
+        mock_file_handle = MagicMock()
+        mock_file_handle.__enter__.return_value.read.return_value = mock_file_content
+        mock_open.return_value = mock_file_handle
+        
+        mock_artefact_from_content.return_value = mock_artefact
 
-    with patch("builtins.print") as mock_print:
+        # Call the function
         set_user_action(args)
 
-        if expected_output is not None:
-            mock_print.assert_called_once_with(expected_output)
-            assert instance_artefact._tags == expected_tags
+        # Verify behavior
+        if artefact_name not in artefact_names:
+            # Should suggest close matches when artefact not found
+            mock_suggest_close_name_matches.assert_called_once_with(artefact_name, artefact_names)
+            mock_artefact_from_content.assert_not_called()
         else:
-            mock_suggest_close_name_matches.assert_called_once_with(
-                "valid_artefact", artefact_names
-            )
+            # Should open the file and read content
+            expected_file_path = next(info["file_path"] for info in artefact_info_dicts if info["title"] == artefact_name)
+            mock_open.assert_any_call(expected_file_path, 'r')
+            mock_artefact_from_content.assert_called_once_with(mock_file_content)
+            
+            # Should set the users attribute on the artefact
+            assert mock_artefact.users == [new_user.lstrip('@') if new_user.startswith('@') else new_user]
+            
+            # Should write the serialized content back to the file
+            mock_open.assert_any_call(expected_file_path, 'w')
+            mock_file_handle.__enter__.return_value.write.assert_called_once_with("serialized_content")
+            
+            # Should print a success message
+            mock_print.assert_called_once_with(expected_output)
 
 
 @pytest.mark.parametrize(
@@ -550,3 +619,68 @@ def test_classifier_directory_action(mock_classifier_get_sub_directory, classifi
         classifier_directory_action(args)
         mock_classifier_get_sub_directory.assert_called_once_with(classifier)
         mock_print.assert_called_once_with(expected_subdirectory)
+
+
+def test_scan_action_with_issues(capsys):
+    args = MagicMock()
+    with patch("ara_cli.file_classifier.FileClassifier") as MockFileClassifier, \
+            patch("ara_cli.artefact_scan.find_invalid_files") as mock_find_invalid_files, \
+            patch("builtins.open", mock_open()) as m:
+
+        mock_classifier = MockFileClassifier.return_value
+        mock_classifier.classify_files_new.return_value = {
+            "classifier1": ["file1.txt"],
+            "classifier2": ["file2.txt"]
+        }
+
+        def find_invalid_side_effect(artefact_files, classifier):
+            if classifier == "classifier1":
+                return [("file1.txt", "reason1")]
+            elif classifier == "classifier2":
+                return []
+
+        mock_find_invalid_files.side_effect = find_invalid_side_effect
+
+        scan_action(args)
+
+        captured = capsys.readouterr()
+        expected_output = (
+            "\nIncompatible classifier1 Files:\n"
+            "\t- file1.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("\n")
+        ]
+        handle.write.assert_has_calls(expected_writes, any_order=False)
+
+
+def test_scan_action_all_good(capsys):
+    args = MagicMock()
+    with patch("ara_cli.file_classifier.FileClassifier") as MockFileClassifier, \
+         patch("ara_cli.artefact_scan.find_invalid_files") as mock_find_invalid_files, \
+         patch("builtins.open", mock_open()) as m:
+
+        mock_classifier = MockFileClassifier.return_value
+        mock_classifier.classify_files_new.return_value = {
+            "classifier1": ["file1.txt"],
+            "classifier2": ["file2.txt"]
+        }
+
+        mock_find_invalid_files.return_value = []
+
+        scan_action(args)
+
+        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)