test_template_endpoint.py

"""Unit tests for TemplateEndpoint class."""

import unittest
from unittest.mock import MagicMock, patch
from datetime import datetime

from pyflowintel.endpoints.templates import TemplateEndpoint
from pyflowintel.api_wrapper import PyFlowintel
from pyflowintel.commons.exceptions import (
    FlowintelBadRequestError,
    FlowintelNotFoundError,
    PyflowintelConfigurationError,
    PyflowintelValidationError
)
from pyflowintel.commons.utils import read_yaml
from pyflowintel.settings import DEFAULT_CONFIG_FILE

# Load configuration for integration tests
_test_config = {}
if DEFAULT_CONFIG_FILE.exists():
    _test_config = read_yaml(DEFAULT_CONFIG_FILE).get("testing", {}) or {}

TEST_BASE_URL = _test_config.get("base_url")
TEST_API_KEY = _test_config.get("api_key")
TEST_TIMEOUT = _test_config.get("timeout", 5)

def skip_if_no_credentials(test_item):
    """Decorator to skip integration tests if credentials are not set."""
    return unittest.skipIf(
        not TEST_API_KEY or not TEST_BASE_URL,
        f"Skipping integration test: api_key or base_url for testing not set in the configuration file"
    )(test_item)


class TestTemplateEndpointValidations(unittest.TestCase):
    """Unit tests for TemplateEndpoint."""

    def setUp(self):
        self.mock_client = MagicMock()
        self.endpoint = TemplateEndpoint(self.mock_client)

    def test_init_sets_base_endpoint_path(self):
        self.assertEqual(self.endpoint.base_endpoint_path, "/templating")

    def test_build_endpoint_path(self):
        self.assertEqual(self.endpoint.build_endpoint_path("/create_case"), "/templating/create_case")
        self.assertEqual(self.endpoint.build_endpoint_path("/case/123"), "/templating/case/123")

    def test_create_case_template_rejects_empty_payload(self):
        '''Covers creation of case and task template as per the implementation'''
        with self.assertRaises(ValueError):
            self.endpoint.create_case_template({})
        self.mock_client.post.assert_not_called()

    def test_create_task_template_rejects_none_payload(self):
        '''Covers creation of case and task template as per the implementation'''
        with self.assertRaises(ValueError):
            self.endpoint.create_task_template(None)
        self.mock_client.post.assert_not_called()

    def test_create_case_from_template_int_validation(self):
        with self.assertRaises(PyflowintelValidationError) as ctx:
            self.endpoint.create_case_from_template(None,"my title")
        self.assertIn("integer", str(ctx.exception))
        self.mock_client.post.assert_not_called()

    def test_find_case_temp_by_id_success(self):
        self.mock_client.get.return_value = {"id": 123, "title": "Test"}
        result = self.endpoint.find_case_temp_by_id(123)
        self.assertEqual(result["id"], 123)
        self.mock_client.get.assert_called_once_with("/templating/case/123")

    def test_find_task_temp_by_id_success(self):
        self.mock_client.get.return_value = {"id": 456, "title": "Task Test"}
        result = self.endpoint.find_task_temp_by_id(456)
        self.assertEqual(result["id"], 456)
        self.mock_client.get.assert_called_once_with("/templating/task/456")

    def test_add_task_templates_to_case_template_case_id_validation(self):
        with self.assertRaises(PyflowintelValidationError) as ctx:
            self.endpoint.add_task_templates_to_case_template("not-int", [1, 2])
        self.assertIn("integer", str(ctx.exception))
        self.mock_client.post.assert_not_called()

    def test_add_task_templates_to_case_template_list_validation(self):
        with self.assertRaises(PyflowintelValidationError) as ctx:
            self.endpoint.add_task_templates_to_case_template(123, [])
        self.assertIn("must not be empty", str(ctx.exception))
        self.mock_client.post.assert_not_called()

    def test_add_task_templates_to_case_template_success(self):
        self.mock_client.post.return_value = {"success": True}
        result = self.endpoint.add_task_templates_to_case_template(123, [1, 2, 3])
        self.assertEqual(result["success"], True)
        self.mock_client.post.assert_called_once_with(
            "/templating/case/123/add_tasks",
            json_data={"tasks": [1, 2, 3]}
        )

    def test_find_case_temp_by_title_empty_title(self):
        with self.assertRaises(PyflowintelValidationError) as ctx:
            self.endpoint.find_case_temp_by_title(" ")
        self.assertIn("Title must not be empty", str(ctx.exception))
        self.mock_client.post.assert_not_called()

    def test_find_case_temp_by_title_success(self):
        self.mock_client.post.return_value = {"id": 321, "title": "My Template"}
        result = self.endpoint.find_case_temp_by_title("My Template")
        self.assertEqual(result["title"], "My Template")
        self.mock_client.post.assert_called_once_with(
            "/templating/case/title",
            json_data={"title": "My Template"}
        )

    @patch("requests.Session.request")
    def test_search_by_id_non_existing_id(self, mock_request):
        client = PyFlowintel.from_args("flowintel/api","mock-api-key")
        mock_response = MagicMock()
        mock_response.status_code = 404
        mock_response.json.return_value = {"message": "Case template not found"}
        mock_request.return_value = mock_response

        response = client.templates.find_case_temp_by_id(99999)
        self.assertIn("message", response.keys())
        mock_request.assert_called_once() 
        _, kwargs = mock_request.call_args
        self.assertEqual(kwargs["url"], f"{client.base_url}/templating/case/99999")

    @patch("requests.Session.request")
    def test_search_by_id_non_existing_server_resource(self, mock_request):
        client = PyFlowintel.from_args("flowintel/api","mock-api-key")
        mock_response = MagicMock()
        mock_response.status_code = 404
        mock_response.json.side_effect = ValueError("Invalid JSON")
        mock_request.return_value = mock_response

        with self.assertRaises(FlowintelNotFoundError) as ctx:
            client.templates.find_case_temp_by_id(99999)

        mock_request.assert_called_once() 
        _, kwargs = mock_request.call_args
        self.assertEqual(kwargs["url"], f"{client.base_url}/templating/case/99999")


@skip_if_no_credentials
class TestCaseTemplateOperations(unittest.TestCase):
    """Integration tests for case template CRUD operations."""

    @classmethod
    def setUpClass(cls):
        cls.client = PyFlowintel.from_args(TEST_BASE_URL, TEST_API_KEY, TEST_TIMEOUT)

        cls.template_payload = {
            "title": "Case template for integration tests",
            "time_required": "10h",
            "description": "Template with fields parsed by the Flowintel API"
        }
        created = cls.client.templates.create_case_template(cls.template_payload)
        cls.template_id = created.get("template_id", 0)

    @classmethod
    def tearDownClass(cls):
        try:
            cls.client.templates.delete_case(cls.template_id)
            cls.client.close()
        except Exception as e:
            print(f"Cleanup failed (ignoring): {e}")

    def test_create_case_template(self):
        """Verify the creation of the case template."""
        self.assertIsInstance(self.template_id, int)
        self.assertGreater(self.template_id, 0)

    def test_create_case_template_duplicate_title_is_rejected(self):
        """Attempt to create another template with the same title.
        Flowintel is expected to reject duplicates with a 400 code (BadRequest).
        """
        with self.assertRaises(FlowintelBadRequestError) as ctx:
            self.client.templates.create_case_template(self.template_payload)
        self.assertIn("Title already exist", str(ctx.exception))

    def test_find_case_temp_by_id(self):
        """Retrieve and verify that the created template has all the defined fields."""
        fetched = self.client.templates.find_case_temp_by_id(self.template_id)
        self.assertIsInstance(fetched, dict)
        for key, value in self.template_payload.items():
            self.assertEqual(fetched.get(key), value)

    def test_find_case_temp_by_title_success(self):
        fetched = self.client.templates.find_case_temp_by_title(self.template_payload.get("title"))
        self.assertIsInstance(fetched, dict)
        for key, value in self.template_payload.items():
            self.assertEqual(fetched.get(key), value)


@skip_if_no_credentials
class TestTaskTemplateOperations(unittest.TestCase):
    """Integration tests for task template CRUD operations."""

    @classmethod
    def setUpClass(cls):
        cls.client = PyFlowintel.from_args(TEST_BASE_URL, TEST_API_KEY, TEST_TIMEOUT)

        cls.task_payload = {
            "title": f"Test Task Template {datetime.now().strftime('%Y%m%d-%H%M%S')}",
            "description": "New task for a case template"
        }
        created = cls.client.templates.create_task_template(cls.task_payload)
        cls.task_template_id = created.get("template_id", 0)

    @classmethod
    def tearDownClass(cls):
        try:
            cls.client.templates.delete_task(cls.task_template_id)
            cls.client.close()
        except Exception as e:
            print(f"Cleanup failed (ignoring): {e}")

    def test_create_task_template(self):
        """Verify task template creation returns valid ID."""
        self.assertIsInstance(self.task_template_id, int)
        self.assertGreater(self.task_template_id, 0)

    def test_find_task_temp_by_id(self):
        """Retrieve and verify that the created task template has all the defined fields."""
        fetched = self.client.templates.find_task_temp_by_id(self.task_template_id)
        self.assertIsInstance(fetched, dict)
        for key, value in self.task_payload.items():
            self.assertEqual(fetched.get(key), value)


@skip_if_no_credentials
class TestCaseFromTemplate(unittest.TestCase):
    """Integration tests for creating cases from templates."""

    @classmethod
    def setUpClass(cls):
        cls.client = PyFlowintel.from_args(TEST_BASE_URL, TEST_API_KEY, TEST_TIMEOUT)

        cls.template_payload = {
            "title": "Integration Test Case Template",
            "time_required": "10h",
            "description": "Template for case creation tests"
        }
        case_template = cls.client.templates.create_case_template(cls.template_payload)
        cls.template_id = case_template.get("template_id", 0)

        cls.case_title = f"Case from template with given title"
        case_w_title = cls.client.templates.create_case_from_template(cls.template_id, cls.case_title)
        cls.id_case_w_title = case_w_title.get("case_id", 0)

        case_no_title = cls.client.templates.create_case_from_template(cls.template_id, None)
        cls.id_case_no_title = case_no_title.get("case_id", 0)

    @classmethod
    def tearDownClass(cls):
        try:
            cls.client.cases.delete(cls.id_case_w_title)
            cls.client.cases.delete(cls.id_case_no_title)
            cls.client.templates.delete_case(cls.template_id)
            cls.client.close()
        except Exception as e:
            print(f"Cleanup failed (ignoring): {e}")

    def test_create_case_from_template_no_title(self):
        """Verify case creation from template when no title is given.
        """
        self.assertGreater(self.id_case_no_title, 0)
        case = self.client.cases.search_by_id(self.id_case_no_title)
        # check that the title of the template is used by default
        self.assertIn(self.template_payload.get("title"), case.get("title"))

    def test_created_case_contains_template_fields(self):
        """Verify case creation from template with fields inherited from the template.
        
        NOTE: Currently, when creating a case from a template in Flowintel 
        the 'time_required' field is not inherited. 
        ToDo: report the issue in the corresponding project (Flowintel).
        """
        self.assertGreater(self.id_case_w_title, 0)
        fetched_case = self.client.cases.search_by_id(self.id_case_w_title)
        self.assertEqual(self.case_title, fetched_case.get("title"))

        # ToDo: uncomment once the error in Flowintel is fixed
        # expected = self.template_payload.copy()
        # expected.pop("title")
        # for k, v in expected.items():
        #     self.assertIn(k, fetched_case)
        #     self.assertEqual(v, fetched_case.get(k))


@skip_if_no_credentials
class TestTemplateTasksToCases(unittest.TestCase):
    """Integration tests for adding tasks to case templates."""

    @classmethod
    def setUpClass(cls):
        try:
            cls.client = PyFlowintel.from_args(TEST_BASE_URL, TEST_API_KEY, TEST_TIMEOUT)
        except PyflowintelConfigurationError as e:
            print(f"Skipping task to cases tests: {e}")
            return

        # Create case template
        case_payload = {
            "title": f"Case Template",
            "description": "Template for testing task relationships"
        }
        created_case = cls.client.templates.create_case_template(case_payload)
        cls.case_template_id = created_case.get("template_id", 0)

        # Create task template
        task_payload = {
            "title": f"Task Template",
            "description": "Task template for relationship testing"
        }
        created_task = cls.client.templates.create_task_template(task_payload)
        cls.task_template_id = created_task.get("template_id", 0)

    @classmethod
    def tearDownClass(cls):
        try:
            cls.client.templates.delete_task(cls.task_template_id)
            cls.client.templates.delete_case(
                cls.case_template_id, 
                delete_tasks=True
            )
            cls.client.close()
        except Exception as e:
            print(f"Cleanup failed (ignoring): {e}")

    def test_add_task_templates_to_case_template(self):
        """Add an existing task template to a case template."""
        result = self.client.templates.add_task_templates_to_case_template(
            self.case_template_id,
            [self.task_template_id]
        )
        self.assertIsInstance(result, dict)
        self.assertIn("Tasks added", result.get("message"))

    def test_add_tasks_to_case_template(self):
        """Create and add tasks from a dictionary list to a case template."""
        tasks = [
            {
                "title": "On-the-fly Task 1",
                "description": "First task created and added directly"
            },
            {
                "title": "On-the-fly Task 2",
                "description": "Second task created and added directly"
            }
        ]
        result = self.client.templates.add_tasks_to_case_template(
            self.case_template_id,
            tasks
        )
        self.assertIn("tasks added", result.get("message").lower())
        self.assertIn("task_templates_added", result)
        task_temp_ids = result.get("task_templates_added")
        self.assertEqual(len(task_temp_ids),2)


if __name__ == "__main__":
    unittest.main()