ara-cli 0.1.9.73__py3-none-any.whl → 0.1.9.75__py3-none-any.whl

tests/test_artefact_scan.py

@@ -1,7 +1,253 @@
 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
+from ara_cli.artefact_scan import (
+    check_file,
+    find_invalid_files,
+    show_results,
+    is_contribution_valid,
+    is_rule_valid,
+    check_contribution,
+)
+
+
+@pytest.mark.parametrize("contribution", [None, False, 0, "", []])
+def test_check_contribution_none_contribution(contribution):
+    # Should return (True, None) if contribution is falsey
+    result = check_contribution(
+        contribution, classified_artefact_info={}, file_path="irrelevant"
+    )
+    assert result == (True, None)
+
+
+def test_check_contribution_invalid_contribution(monkeypatch):
+    # If is_contribution_valid returns False, should return (False, custom_reason)
+    contribution = MagicMock()
+    contribution.classifier = "some_cls"
+    contribution.artefact_name = "some_art"
+    with patch(
+        "ara_cli.artefact_scan.is_contribution_valid", return_value=False
+    ) as mock_is_contrib, patch("ara_cli.artefact_scan.is_rule_valid") as mock_is_rule:
+        result = check_contribution(
+            contribution, classified_artefact_info={}, file_path="f"
+        )
+        assert result == (
+            False,
+            "Invalid Contribution Reference: The contribution references "
+            "'some_cls' artefact 'some_art' which does not exist.",
+        )
+        mock_is_contrib.assert_called_once_with(contribution, {})
+        mock_is_rule.assert_not_called()
+
+
+def test_check_contribution_invalid_rule(monkeypatch):
+    # is_contribution_valid returns True, is_rule_valid returns False
+    contribution = MagicMock()
+    contribution.classifier = "c"
+    contribution.artefact_name = "a"
+    contribution.rule = "r"
+    with patch(
+        "ara_cli.artefact_scan.is_contribution_valid", return_value=True
+    ) as mock_is_contrib, patch(
+        "ara_cli.artefact_scan.is_rule_valid", return_value=False
+    ) as mock_is_rule:
+        result = check_contribution(
+            contribution, classified_artefact_info={"x": 1}, file_path="myfile"
+        )
+        assert result == (
+            False,
+            "Rule Mismatch: The contribution references rule 'r' which the parent c 'a' does not have.",
+        )
+        mock_is_contrib.assert_called_once_with(contribution, {"x": 1})
+        mock_is_rule.assert_called_once_with(contribution, {"x": 1})
+
+
+def test_check_contribution_all_valid(monkeypatch):
+    # Both is_contribution_valid and is_rule_valid return True
+    contribution = MagicMock()
+    contribution.classifier = "c"
+    contribution.artefact_name = "a"
+    contribution.rule = "r"
+    with patch(
+        "ara_cli.artefact_scan.is_contribution_valid", return_value=True
+    ) as mock_is_contrib, patch(
+        "ara_cli.artefact_scan.is_rule_valid", return_value=True
+    ) as mock_is_rule:
+        result = check_contribution(
+            contribution, classified_artefact_info={1: 2}, file_path="p"
+        )
+        assert result == (True, None)
+        mock_is_contrib.assert_called_once_with(contribution, {1: 2})
+        mock_is_rule.assert_called_once_with(contribution, {1: 2})
+
+
+@pytest.mark.parametrize(
+    "contribution_attrs,expected",
+    [
+        (None, True),  # contribution is None
+        ({"artefact_name": None, "classifier": "foo"}, True),  # artefact_name is None
+        (
+            {"artefact_name": "", "classifier": "foo"},
+            True,
+        ),  # artefact_name is empty string
+        ({"artefact_name": "bar", "classifier": None}, True),  # classifier is None
+        (
+            {"artefact_name": "bar", "classifier": ""},
+            True,
+        ),  # classifier is empty string
+    ],
+)
+def test_is_rule_valid_short_circuits(contribution_attrs, expected):
+    if contribution_attrs is None:
+        contribution = None
+    else:
+        contribution = MagicMock()
+        for k, v in contribution_attrs.items():
+            setattr(contribution, k, v)
+    with patch("ara_cli.artefact_reader.ArtefactReader.read_artefact") as mock_read:
+        result = is_rule_valid(contribution, classified_artefact_info={})
+        assert result is expected
+        mock_read.assert_not_called()
+
+
+def test_is_rule_valid_rule_is_none():
+    """Should return True if contribution.rule is None or falsey."""
+    contribution = MagicMock()
+    contribution.artefact_name = "foo"
+    contribution.classifier = "bar"
+    contribution.rule = None
+    with patch("ara_cli.artefact_reader.ArtefactReader.read_artefact") as mock_read:
+        result = is_rule_valid(contribution, classified_artefact_info={})
+        assert result is True
+        mock_read.assert_not_called()
+
+    # Also test rule as empty string
+    contribution.rule = ""
+    with patch("ara_cli.artefact_reader.ArtefactReader.read_artefact") as mock_read:
+        result = is_rule_valid(contribution, classified_artefact_info={})
+        assert result is True
+        mock_read.assert_not_called()
+
+
+@pytest.mark.parametrize(
+    "parent,expected",
+    [
+        (None, True),  # parent is None
+        (MagicMock(rules=None), True),  # parent.rules is None
+    ],
+)
+def test_is_rule_valid_parent_or_rules_none(parent, expected):
+    contribution = MagicMock()
+    contribution.artefact_name = "foo"
+    contribution.classifier = "bar"
+    contribution.rule = "r1"
+    with patch(
+        "ara_cli.artefact_reader.ArtefactReader.read_artefact", return_value=parent
+    ) as mock_read:
+        result = is_rule_valid(contribution, classified_artefact_info={})
+        assert result is expected
+        mock_read.assert_called_once_with("foo", "bar")
+
+
+def test_is_rule_valid_rule_not_in_parent_rules():
+    """Should return False if rule is not in parent.rules."""
+    contribution = MagicMock()
+    contribution.artefact_name = "foo"
+    contribution.classifier = "bar"
+    contribution.rule = "missing_rule"
+    parent = MagicMock()
+    parent.rules = ["rule1", "rule2"]
+    with patch(
+        "ara_cli.artefact_reader.ArtefactReader.read_artefact", return_value=parent
+    ) as mock_read:
+        result = is_rule_valid(contribution, classified_artefact_info={})
+        assert result is False
+        mock_read.assert_called_once_with("foo", "bar")
+
+
+def test_is_rule_valid_rule_in_parent_rules():
+    """Should return True if rule is in parent.rules."""
+    contribution = MagicMock()
+    contribution.artefact_name = "foo"
+    contribution.classifier = "bar"
+    contribution.rule = "my_rule"
+    parent = MagicMock()
+    parent.rules = ["my_rule", "other_rule"]
+    with patch(
+        "ara_cli.artefact_reader.ArtefactReader.read_artefact", return_value=parent
+    ) as mock_read:
+        result = is_rule_valid(contribution, classified_artefact_info={})
+        assert result is True
+        mock_read.assert_called_once_with("foo", "bar")
+
+
+@pytest.mark.parametrize(
+    "contribution_attrs,expected",
+    [
+        # contribution is None
+        (None, True),
+        # artefact_name missing/None/empty
+        ({"artefact_name": None, "classifier": "foo"}, True),
+        ({"artefact_name": "", "classifier": "foo"}, True),
+        # classifier missing/None/empty
+        ({"artefact_name": "bar", "classifier": None}, True),
+        ({"artefact_name": "bar", "classifier": ""}, True),
+    ],
+)
+def test_is_contribution_valid_short_circuits(contribution_attrs, expected):
+    classified_artefact_info = {"dummy": []}
+    if contribution_attrs is None:
+        contribution = None
+    else:
+        contribution = MagicMock()
+        for k, v in contribution_attrs.items():
+            setattr(contribution, k, v)
+    with patch(
+        "ara_cli.artefact_fuzzy_search.extract_artefact_names_of_classifier"
+    ) as mock_extract:
+        result = is_contribution_valid(contribution, classified_artefact_info)
+        assert result is expected
+        # The extract function should NOT be called in these cases
+        mock_extract.assert_not_called()
+
+
+def test_is_contribution_valid_references_existing_artefact():
+    """
+    contribution with valid artefact_name and classifier,
+    artefact_name IS in list returned by extract_artefact_names_of_classifier.
+    """
+    contribution = MagicMock()
+    contribution.artefact_name = "valid_art"
+    contribution.classifier = "valid_clf"
+    classified_artefact_info = {"valid_clf": [{"name": "valid_art"}]}
+    with patch(
+        "ara_cli.artefact_fuzzy_search.extract_artefact_names_of_classifier",
+        return_value=["valid_art"],
+    ) as mock_extract:
+        result = is_contribution_valid(contribution, classified_artefact_info)
+        assert result is True
+        mock_extract.assert_called_once_with(
+            classified_files=classified_artefact_info, classifier="valid_clf"
+        )
+
+
+def test_is_contribution_valid_references_missing_artefact():
+    """
+    contribution with valid artefact_name and classifier,
+    artefact_name is NOT in list returned by extract_artefact_names_of_classifier.
+    """
+    contribution = MagicMock()
+    contribution.artefact_name = "missing_art"
+    contribution.classifier = "some_clf"
+    classified_artefact_info = {"some_clf": [{"name": "another"}]}
+    with patch(
+        "ara_cli.artefact_fuzzy_search.extract_artefact_names_of_classifier",
+        return_value=["another", "something_else"],
+    ) as mock_extract:
+        result = is_contribution_valid(contribution, classified_artefact_info)
+        assert result is False
+        mock_extract.assert_called_once_with(
+            classified_files=classified_artefact_info, classifier="some_clf"
+        )
 
 
 def test_check_file_valid():
@@ -16,8 +262,10 @@ def test_check_file_valid():
 
     with patch("builtins.open", mock_open(read_data="valid content")):
         is_valid, reason = check_file("dummy_path.feature", mock_artefact_class)
-        
-    assert reason is None, f"Reason for invalid found, expected none to be found. The reason found: {reason}"
+
+    assert (
+        reason is None
+    ), f"Reason for invalid found, expected none to be found. The reason found: {reason}"
     assert is_valid is True, "File detected as invalid, expected to be valid"
 
 
@@ -51,8 +299,7 @@ def test_check_file_value_error():
 
 def test_check_file_assertion_error():
     mock_artefact_class = MagicMock()
-    mock_artefact_class.deserialize.side_effect = AssertionError(
-        "Assertion error")
+    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)
@@ -78,6 +325,7 @@ def test_check_file_unexpected_error():
         assert is_valid is False
         assert "Unexpected error: Exception('Unexpected error')" in reason
 
+
 # Tests for find_invalid_files
 
 
@@ -86,32 +334,37 @@ def test_find_invalid_files():
     mock_artefact_class = MagicMock()
     classified_info = {
         "test_classifier": [
-            {"file_path": "file1.txt"},              # Should be checked
-            {"file_path": "file2.txt"},              # Should be checked
-            {"file_path": "templates/file3.txt"},    # Should be skipped
-            {"file_path": "some/path/file.data"}     # Should be skipped
+            {"file_path": "file1.txt"},  # Should be checked
+            {"file_path": "file2.txt"},  # Should be checked
+            {"file_path": "templates/file3.txt"},  # Should be skipped
+            {"file_path": "some/path/file.data"},  # Should be skipped
         ]
     }
-    
-    with patch("ara_cli.artefact_models.artefact_mapping.artefact_type_mapping", 
-              {"test_classifier": mock_artefact_class}):
+
+    with patch(
+        "ara_cli.artefact_models.artefact_mapping.artefact_type_mapping",
+        {"test_classifier": mock_artefact_class},
+    ):
         with patch("ara_cli.artefact_scan.check_file") as mock_check_file:
             mock_check_file.side_effect = [
-                (True, None),              # for file1.txt
-                (False, "Invalid content") # for file2.txt
+                (True, None),  # for file1.txt
+                (False, "Invalid content"),  # for file2.txt
             ]
 
             invalid_files = find_invalid_files(classified_info, "test_classifier")
-            
+
             assert len(invalid_files) == 1
             assert invalid_files[0] == ("file2.txt", "Invalid content")
             assert mock_check_file.call_count == 2
-            
+
             # Check that check_file was called with the correct parameters
-            mock_check_file.assert_has_calls([
-                call("file1.txt", mock_artefact_class, classified_info),
-                call("file2.txt", mock_artefact_class, classified_info)
-            ], any_order=False)
+            mock_check_file.assert_has_calls(
+                [
+                    call("file1.txt", mock_artefact_class, classified_info),
+                    call("file2.txt", mock_artefact_class, classified_info),
+                ],
+                any_order=False,
+            )
 
 
 def test_show_results_no_issues(capsys):
@@ -120,18 +373,20 @@ def test_show_results_no_issues(capsys):
         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", encoding="utf-8")
+        m.assert_called_once_with(
+            "incompatible_artefacts_report.md", "w", encoding="utf-8"
+        )
         handle = m()
-        handle.write.assert_has_calls([
-            call("# Artefact Check Report\n\n"),
-            call("No problems found.\n")
-        ], any_order=False)
+        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")]
+        "classifier2": [("file3.txt", "reason3")],
     }
     with patch("builtins.open", mock_open()) as m:
         show_results(invalid_artefacts)
@@ -147,7 +402,9 @@ def test_show_results_with_issues(capsys):
             "\t\treason3\n"
         )
         assert captured.out == expected_output
-        m.assert_called_once_with("incompatible_artefacts_report.md", "w", encoding="utf-8")
+        m.assert_called_once_with(
+            "incompatible_artefacts_report.md", "w", encoding="utf-8"
+        )
         handle = m()
         expected_writes = [
             call("# Artefact Check Report\n\n"),
@@ -157,7 +414,7 @@ def test_show_results_with_issues(capsys):
             call("\n"),
             call("## classifier2\n"),
             call("- `file3.txt`: reason3\n"),
-            call("\n")
+            call("\n"),
         ]
         handle.write.assert_has_calls(expected_writes, any_order=False)
 
@@ -166,7 +423,7 @@ def test_check_file_with_invalid_contribution():
     """Tests file with invalid contribution reference."""
     mock_artefact_instance = MagicMock()
     mock_artefact_instance.title = "dummy_path"
-    
+
     # Set up invalid contribution
     mock_contribution = MagicMock()
     mock_contribution.classifier = "test_classifier"
@@ -178,12 +435,16 @@ def test_check_file_with_invalid_contribution():
 
     # Mock classified_artefact_info
     classified_info = {"test_classifier": [{"name": "existing_artefact"}]}
-    
+
     # Mock extract_artefact_names_of_classifier to return a list without the referenced artefact
     with patch("builtins.open", mock_open(read_data="valid content")):
-        with patch("ara_cli.artefact_fuzzy_search.extract_artefact_names_of_classifier", 
-                  return_value=["existing_artefact"]):
-            is_valid, reason = check_file("dummy_path.feature", mock_artefact_class, classified_info)
-    
+        with patch(
+            "ara_cli.artefact_fuzzy_search.extract_artefact_names_of_classifier",
+            return_value=["existing_artefact"],
+        ):
+            is_valid, reason = check_file(
+                "dummy_path.feature", mock_artefact_class, classified_info
+            )
+
     assert is_valid is False
     assert "Invalid Contribution Reference" in reason

tests/test_chat.py

@@ -13,8 +13,8 @@ from ara_cli.ara_config import ConfigManager
 def get_default_config():
     return SimpleNamespace(
         ext_code_dirs=[
-            {"source_dir_1": "./src"},
-            {"source_dir_2": "./tests"},
+            {"source_dir": "./src"},
+            {"source_dir": "./tests"},
         ],
         glossary_dir="./glossary",
         doc_dir="./docs",
@@ -1052,19 +1052,39 @@ def test_do_SEND(temp_chat_file):
             mock_send_message.assert_called_once()
 
 
-def test_do_LOAD_TEMPLATE(temp_chat_file):
-    mock_config = get_default_config()
+@pytest.mark.parametrize("template_name, artefact_obj, expected_write, expected_print", [
+    ("TestTemplate", MagicMock(serialize=MagicMock(return_value="serialized_content")), "serialized_content", "Loaded TestTemplate artefact template\n"),
+    ("AnotherTemplate", MagicMock(serialize=MagicMock(return_value="other_content")), "other_content", "Loaded AnotherTemplate artefact template\n"),
+])
+def test_do_LOAD_TEMPLATE_success(temp_chat_file, template_name, artefact_obj, expected_write, expected_print, capsys):
+    mock_config = MagicMock()  # or use get_default_config() if needed
     with patch('ara_cli.prompt_handler.ConfigManager.get_config', return_value=mock_config):
         chat = Chat(temp_chat_file.name, reset=False)
-    template_name = 'test_template'
-
-    module_path = os.path.abspath(os.path.dirname(ara_cli.__file__))
-    directory = f'{module_path}/templates'
-    pattern = f"template.{template_name}"
-    file_type = "template"
-    exclude_pattern = os.path.join(directory, "template.*.prompt_log.md")
-
-    with patch.object(chat, '_load_helper') as mock_load_helper:
+    # Patch the artefact loader to return artefact_obj
+    with patch('ara_cli.artefact_models.artefact_templates.template_artefact_of_type', return_value=artefact_obj) as mock_template_loader, \
+         patch.object(chat, 'add_prompt_tag_if_needed') as mock_add_prompt_tag, \
+         patch("builtins.open", mock_open()) as mock_file:
         chat.do_LOAD_TEMPLATE(template_name)
-
-    mock_load_helper.assert_called_once_with(directory, pattern, file_type, exclude_pattern)
+        mock_template_loader.assert_called_once_with(template_name)
+        artefact_obj.serialize.assert_called_once_with()
+        mock_add_prompt_tag.assert_called_once_with(chat.chat_name)
+        mock_file.assert_called_with(chat.chat_name, 'a', encoding='utf-8')
+        mock_file().write.assert_called_once_with(expected_write)
+        out = capsys.readouterr()
+        assert expected_print in out.out
+
+@pytest.mark.parametrize("template_name", [
+    ("MissingTemplate"),
+    (""),
+])
+def test_do_LOAD_TEMPLATE_missing_artefact(temp_chat_file, template_name):
+    mock_config = MagicMock()
+    with patch('ara_cli.prompt_handler.ConfigManager.get_config', return_value=mock_config):
+        chat = Chat(temp_chat_file.name, reset=False)
+    with patch('ara_cli.artefact_models.artefact_templates.template_artefact_of_type', return_value=None) as mock_template_loader, \
+         patch.object(chat, 'add_prompt_tag_if_needed') as mock_add_prompt_tag, \
+         patch("builtins.open", mock_open()) as mock_file:
+        chat.do_LOAD_TEMPLATE(template_name)
+        mock_template_loader.assert_called_once_with(template_name)
+        mock_add_prompt_tag.assert_not_called()
+        mock_file.assert_not_called()

ara_cli/templates/template.businessgoal

@@ -1,10 +0,0 @@
-@sample_tag
-Businessgoal: <descriptive title>
-
-Contributes to <filename or title of the artefact> <agile requirement artefact category> <(optional in case the contribution is to an artefact that is detailed with rules) using rule <rule as it is formulated>
-
-In order to <reach primarily a monetary business goal>
-As a <business related role>  
-I want <something that helps me to reach my monetary goal>
-
-Description: <further optional description to understand the business goal, markdown capable text formatting>

ara_cli/templates/template.capability

@@ -1,10 +0,0 @@
-@sample_tag
-Capability: <descriptive title>
-
-Contributes to <filename or title of the artefact> <agile requirement artefact category> <(optional in case the contribution is to an artefact that is detailed with rules) using rule <rule as it is formulated>
-
-To be able to <needed capability for stakeholders that are the
-enablers/relevant for reaching the business goal>
-
-Description: <further optional description to understand
-the capability, markdown capable text formatting>

ara_cli/templates/template.epic

@@ -1,15 +0,0 @@
-@sample_tag
-Epic: <descriptive title>
-
-Contributes to <filename or title of the artefact> <agile requirement artefact category> <(optional in case the contribution is to an artefact that is detailed with rules) using rule <rule as it is formulated>
-
-In order to <achieve a benefit>
-As a <(user) role>
-I want <a certain product behavior>
-
-Rule: <rule needed to fulfill the wanted product behavior>
-Rule: <rule needed to fulfill the wanted product behavior>
-Rule: <rule needed to fulfill the wanted product behavior>
-
-Description: <further optional description to understand
-the epic, markdown capable text formatting>

ara_cli/templates/template.example

@@ -1,6 +0,0 @@
-@sample_tag
-Example: <descriptive title>
-
-Illustrates <filename or title of the artefact> <agile requirement artefact category> <(optional in case the contribution is to an artefact that is detailed with rules) using rule <rule as it is formulated>
-
-Description: <further optional description to understand the rule, no format defined, the example artefact is only a placeholder>

ara_cli/templates/template.feature

@@ -1,26 +0,0 @@
-@sample_tag
-Feature: <descriptive title>
-
-  As a <user>
-  I want to <do something | need something>
-  So that <I can achieve something>
-
-  Contributes to <filename or title of the artefact> <agile requirement artefact category> <(optional in case the contribution is to an artefact that is detailed with rules) using rule <rule as it is formulated>   
-
-  Description: <further optional description to understand
-  the rule, no format defined, the example artefact is only a placeholder>
-
-  Scenario: <descriptive scenario title>
-    Given <precondition>
-    When <action>
-    Then <expected result>
-
-  Scenario Outline: <descriptive scenario title>
-    Given <precondition>
-    When <action>
-    Then <expected result>
-
-    Examples:
-      | descriptive scenario title | precondition         | action             | expected result    |
-      | <example title 1>          | <example precond. 1> | <example action 1> | <example result 1> |
-      | <example title 2>          | <example precond. 2> | <example action 2> | <example result 2> |

ara_cli/templates/template.issue

@@ -1,14 +0,0 @@
-@sample_tag
-Issue: <descriptive issue>
-
-Contributes to <filename or title of the artefact> <agile requirement artefact category> <(optional in case the contribution is to an artefact that is detailed with rules) using rule <rule as it is formulated>  | blank | filled with text that does not refer to an artefact or rule (then this a free issue)
-
-*Optional descriptions of the issue in Gherkin style*
-
-Given <descriptive text of the starting conditions where the issue occurs>
-When <action under which the issues occurs>
-Then <resulting behavior in contrast to the expected behavior>
-
-*or optional free text description*
-
-Description: <further free text description to understand the issue, no format defined>

ara_cli/templates/template.keyfeature

@@ -1,15 +0,0 @@
-@sample_tag
-Keyfeature: <descriptive title>
-
-Contributes to <filename or title of the artefact> <agile requirement artefact category> <(optional in case the contribution is to an artefact that is detailed with rules) using rule <rule as it is formulated>
-
-In order to <support a capability or business goal>
-As a <main stakeholder who will benefit>
-I want <a product feature that helps me doing something so that I can achieve my named goal>
-
-Description: <further optional description to understand the capability, markdown capable text formatting, best practice is using
-    GIVEN any precondition
-    AND another precondition
-    WHEN some action takes place
-    THEN some result is to be expected
-    AND some other result is to be expected>

ara_cli/templates/template.task

@@ -1,6 +0,0 @@
-@to-do
-Task: <descriptive title>
-
-Contributes to <filename or title of the artefact> <agile requirement artefact category> <(optional in case the contribution is to an artefact that is detailed with rules) using rule <rule as it is formulated>  | blank | filled with text that does not refer to an artefact or rule (then this is a free task)
-
-Description: <further optional description to understand the task, no format defined>

ara_cli/templates/template.userstory

@@ -1,17 +0,0 @@
-@sample_tag
-Userstory: <descriptive title>
-
-Contributes to <filename or title of the artefact> <agile requirement artefact category> <(optional in case the contribution is to an artefact that is detailed with rules) using rule <rule as it is formulated>
-
-Estimate: <story points, scale?>
-
-In order to <achieve a benefit>
-As a <(user) role>
-I want <a certain product behavior>
-
-Rule: <rule needed to fulfill the wanted product behavior>
-Rule: <rule needed to fulfill the wanted product behavior>
-Rule: <rule needed to fulfill the wanted product behavior>
-
-Description: <further optional description to understand
-the user story, markdown capable text formatting>

ara_cli/templates/template.vision

@@ -1,14 +0,0 @@
-@sample_tag
-Vision: <descriptive title>
-
-Contributes to <filename or title of the artefact> <agile requirement artefact category> <(optional in case the contribution is to an artefact that is detailed with rules) using rule <rule as it is formulated>
-
-For <target customer>
-Who <needs something>
-The <product name> is a <product category>
-That <key benefit, compelling reason to buy>
-Unlike <primary competitive alternative>
-Our product <statement of primary differentiation>
-
-Description: <further optional description to understand
-the vision, markdown capable text formatting>