Skip to content

Home Information - Your home, your data, organized.

Python
18.9 KB
Raw Blame
"""
Tests for AttributeResponse and AttributeResponseBuilder classes.

Focuses on high-value business logic: response data structure creation,
JSON serialization, HTTP response generation, and builder pattern functionality.
These are critical for client-server communication consistency.
"""
import json
import logging
from django.http import HttpResponse
from django.test import TestCase

from hi.apps.attribute.response_helpers import (
    AttributeResponse,
    AttributeResponseBuilder,
    DOMUpdate,
)
from hi.apps.attribute.response_constants import (
    DefaultMessages,
    HTTPHeaders,
    ResponseFields,
    UpdateMode,
)

logging.disable(logging.CRITICAL)


class TestDOMUpdate(TestCase):
    """Test DOMUpdate dataclass - critical for DOM manipulation instructions."""

    def test_dom_update_basic_creation(self):
        """Test basic DOMUpdate creation and property access."""
        update = DOMUpdate(
            target="#test-element",
            html="<div>Test Content</div>",
            mode=UpdateMode.REPLACE
        )
        
        self.assertEqual(update.target, "#test-element")
        self.assertEqual(update.html, "<div>Test Content</div>")
        self.assertEqual(update.mode, UpdateMode.REPLACE)

    def test_dom_update_default_mode(self):
        """Test DOMUpdate uses REPLACE as default mode."""
        update = DOMUpdate(
            target="#test-element",
            html="<div>Test Content</div>"
        )
        
        self.assertEqual(update.mode, UpdateMode.REPLACE)

    def test_dom_update_to_dict_conversion(self):
        """Test DOMUpdate serialization to dictionary - critical for JSON response."""
        update = DOMUpdate(
            target="#test-element",
            html="<div>Test Content</div>",
            mode=UpdateMode.APPEND
        )
        
        result = update.to_dict()
        expected = {
            ResponseFields.TARGET: "#test-element",
            ResponseFields.HTML: "<div>Test Content</div>",
            ResponseFields.MODE: "append",
        }
        
        self.assertEqual(result, expected)

    def test_dom_update_all_mode_types(self):
        """Test DOMUpdate works with all update modes - enum consistency."""
        modes_and_values = [
            (UpdateMode.REPLACE, "replace"),
            (UpdateMode.APPEND, "append"), 
            (UpdateMode.PREPEND, "prepend"),
        ]
        
        for mode_enum, mode_value in modes_and_values:
            update = DOMUpdate(
                target="#test", 
                html="<div>test</div>", 
                mode=mode_enum
            )
            result = update.to_dict()
            self.assertEqual(result[ResponseFields.MODE], mode_value)


class TestAttributeResponse(TestCase):
    """Test AttributeResponse dataclass - critical for response structure."""

    def test_attribute_response_success_basic(self):
        """Test basic successful AttributeResponse creation."""
        response = AttributeResponse(
            success=True,
            message="Operation completed"
        )
        
        self.assertTrue(response.success)
        self.assertEqual(response.message, "Operation completed")
        self.assertEqual(len(response.updates), 0)

    def test_attribute_response_error_basic(self):
        """Test basic error AttributeResponse creation."""
        response = AttributeResponse(
            success=False,
            message="Validation failed"
        )
        
        self.assertFalse(response.success)
        self.assertEqual(response.message, "Validation failed")

    def test_attribute_response_with_updates(self):
        """Test AttributeResponse with DOM updates - complex data structure."""
        update1 = DOMUpdate("#element1", "<div>Content 1</div>", UpdateMode.REPLACE)
        update2 = DOMUpdate("#element2", "<div>Content 2</div>", UpdateMode.APPEND)
        
        response = AttributeResponse(
            success=True,
            updates=[update1, update2],
            message="Multiple updates applied"
        )
        
        self.assertTrue(response.success)
        self.assertEqual(len(response.updates), 2)
        self.assertEqual(response.updates[0], update1)
        self.assertEqual(response.updates[1], update2)

    def test_attribute_response_to_dict_complete(self):
        """Test complete AttributeResponse dictionary serialization."""
        update = DOMUpdate("#test-element", "<div>Test</div>", UpdateMode.REPLACE)
        response = AttributeResponse(
            success=True,
            updates=[update],
            message="Test message"
        )
        
        result = response.to_dict()
        expected = {
            ResponseFields.SUCCESS: True,
            ResponseFields.UPDATES: [
                {
                    ResponseFields.TARGET: "#test-element",
                    ResponseFields.HTML: "<div>Test</div>",
                    ResponseFields.MODE: "replace"
                }
            ],
            ResponseFields.MESSAGE: "Test message"
        }
        
        self.assertEqual(result, expected)

    def test_attribute_response_to_dict_no_message(self):
        """Test AttributeResponse serialization without message - optional field handling."""
        response = AttributeResponse(success=True, updates=[])
        result = response.to_dict()
        
        self.assertIn(ResponseFields.SUCCESS, result)
        self.assertIn(ResponseFields.UPDATES, result)
        self.assertNotIn(ResponseFields.MESSAGE, result)

    def test_attribute_response_to_http_response_success(self):
        """Test HTTP response generation - critical for Django integration."""
        response = AttributeResponse(
            success=True,
            message="Success"
        )
        
        http_response = response.to_http_response()
        
        self.assertIsInstance(http_response, HttpResponse)
        self.assertEqual(http_response.status_code, 200)
        self.assertEqual(http_response['Content-Type'], HTTPHeaders.APPLICATION_JSON)
        
        # Verify JSON content
        response_data = json.loads(http_response.content)
        self.assertTrue(response_data[ResponseFields.SUCCESS])
        self.assertEqual(response_data[ResponseFields.MESSAGE], "Success")

    def test_attribute_response_to_http_response_custom_status(self):
        """Test HTTP response with custom status code."""
        response = AttributeResponse(success=False)
        http_response = response.to_http_response(status_code=400)
        
        self.assertEqual(http_response.status_code, 400)

    def test_attribute_response_json_serialization_edge_cases(self):
        """Test JSON serialization handles edge cases - robustness testing."""
        # Empty updates list
        response = AttributeResponse(success=True, updates=[])
        result = response.to_dict()
        self.assertEqual(result[ResponseFields.UPDATES], [])
        
        # Special characters in HTML
        update = DOMUpdate("#test", "<div class=\"special-class\">Content</div>")
        response = AttributeResponse(success=True, updates=[update])
        result = response.to_dict()
        expected_html = "<div class=\"special-class\">Content</div>"
        self.assertEqual(result[ResponseFields.UPDATES][0][ResponseFields.HTML], expected_html)


class TestAttributeResponseBuilder(TestCase):
    """Test AttributeResponseBuilder - critical for fluent API pattern."""

    def test_builder_success_basic(self):
        """Test basic success response building."""
        builder = AttributeResponseBuilder()
        response = builder.success().build()
        
        self.assertIsInstance(response, AttributeResponse)
        self.assertTrue(response.success)
        self.assertEqual(len(response.updates), 0)
        self.assertIsNone(response.message)

    def test_builder_error_basic(self):
        """Test basic error response building."""
        builder = AttributeResponseBuilder()
        response = builder.error().build()
        
        self.assertIsInstance(response, AttributeResponse)
        self.assertFalse(response.success)

    def test_builder_fluent_interface_chaining(self):
        """Test builder method chaining - fluent interface functionality."""
        builder = AttributeResponseBuilder()
        result = (builder
                  .success()
                  .with_message("Test message")
                  .add_update("#element", "<div>content</div>", UpdateMode.REPLACE))
        
        # Verify chaining returns the same builder instance
        self.assertIs(result, builder)
        
        response = result.build()
        self.assertTrue(response.success)
        self.assertEqual(response.message, "Test message")
        self.assertEqual(len(response.updates), 1)

    def test_builder_add_multiple_updates(self):
        """Test builder can accumulate multiple updates."""
        response = (AttributeResponseBuilder()
                    .success()
                    .add_update("#element1", "<div>Content 1</div>", UpdateMode.REPLACE)
                    .add_update("#element2", "<div>Content 2</div>", UpdateMode.APPEND)
                    .add_update("#element3", "<div>Content 3</div>", UpdateMode.PREPEND)
                    .build())
        
        self.assertEqual(len(response.updates), 3)
        self.assertEqual(response.updates[0].target, "#element1")
        self.assertEqual(response.updates[0].mode, UpdateMode.REPLACE)
        self.assertEqual(response.updates[1].target, "#element2")
        self.assertEqual(response.updates[1].mode, UpdateMode.APPEND)
        self.assertEqual(response.updates[2].target, "#element3")
        self.assertEqual(response.updates[2].mode, UpdateMode.PREPEND)

    def test_builder_message_override_behavior(self):
        """Test builder message can be set and overridden."""
        response = (AttributeResponseBuilder()
                    .success("First message")
                    .with_message("Second message")
                    .build())
        
        self.assertEqual(response.message, "Second message")

    def test_builder_success_error_state_switching(self):
        """Test builder can switch between success and error states."""
        builder = AttributeResponseBuilder()
        
        # Start as success, switch to error
        response1 = builder.success().error().build()
        self.assertFalse(response1.success)
        
        # Switch back to success
        response2 = builder.success().build()
        self.assertTrue(response2.success)

    def test_builder_build_http_response_default_status(self):
        """Test builder HTTP response generation with default status codes."""
        # Success response defaults to 200
        success_response = (AttributeResponseBuilder()
                            .success()
                            .build_http_response())
        self.assertEqual(success_response.status_code, 200)
        
        # Error response defaults to 400
        error_response = (AttributeResponseBuilder()
                          .error()
                          .build_http_response())
        self.assertEqual(error_response.status_code, 400)

    def test_builder_build_http_response_custom_status(self):
        """Test builder HTTP response with custom status code."""
        response = (AttributeResponseBuilder()
                    .success()
                    .build_http_response(status_code=201))
        
        self.assertEqual(response.status_code, 201)

    def test_builder_build_http_response_json_content(self):
        """Test builder HTTP response contains valid JSON - integration testing."""
        http_response = (AttributeResponseBuilder()
                         .success()
                         .add_update("#test", "<div>Test</div>")
                         .with_message("Test message")
                         .build_http_response())
        
        # Verify response structure
        self.assertEqual(http_response['Content-Type'], HTTPHeaders.APPLICATION_JSON)
        
        # Verify JSON parsing and content
        response_data = json.loads(http_response.content)
        self.assertTrue(response_data[ResponseFields.SUCCESS])
        self.assertEqual(response_data[ResponseFields.MESSAGE], "Test message")
        self.assertEqual(len(response_data[ResponseFields.UPDATES]), 1)
        self.assertEqual(response_data[ResponseFields.UPDATES][0][ResponseFields.TARGET], "#test")

    def test_builder_create_success_response_class_method(self):
        """Test convenience class method for success responses."""
        update1 = DOMUpdate("#element1", "<div>Content 1</div>", UpdateMode.REPLACE)
        update2 = DOMUpdate("#element2", "<div>Content 2</div>", UpdateMode.APPEND)
        
        http_response = AttributeResponseBuilder.create_success_response(
            updates=[update1, update2],
            message="Custom success message",
            status_code=201
        )
        
        self.assertIsInstance(http_response, HttpResponse)
        self.assertEqual(http_response.status_code, 201)
        
        response_data = json.loads(http_response.content)
        self.assertTrue(response_data[ResponseFields.SUCCESS])
        self.assertEqual(response_data[ResponseFields.MESSAGE], "Custom success message")
        self.assertEqual(len(response_data[ResponseFields.UPDATES]), 2)

    def test_builder_create_success_response_default_message(self):
        """Test success response class method uses default message."""
        http_response = AttributeResponseBuilder.create_success_response(updates=[])
        
        response_data = json.loads(http_response.content)
        self.assertEqual(response_data[ResponseFields.MESSAGE], DefaultMessages.SAVE_SUCCESS)

    def test_builder_create_error_response_class_method(self):
        """Test convenience class method for error responses."""
        update = DOMUpdate("#error-element", "<div>Error content</div>", UpdateMode.REPLACE)
        
        http_response = AttributeResponseBuilder.create_error_response(
            updates=[update],
            message="Custom error message",
            status_code=422
        )
        
        self.assertIsInstance(http_response, HttpResponse)
        self.assertEqual(http_response.status_code, 422)
        
        response_data = json.loads(http_response.content)
        self.assertFalse(response_data[ResponseFields.SUCCESS])
        self.assertEqual(response_data[ResponseFields.MESSAGE], "Custom error message")

    def test_builder_create_error_response_default_message(self):
        """Test error response class method uses default message."""
        http_response = AttributeResponseBuilder.create_error_response(updates=[])
        
        response_data = json.loads(http_response.content)
        self.assertEqual(response_data[ResponseFields.MESSAGE], DefaultMessages.SAVE_ERROR)

    def test_builder_create_upload_success_response_class_method(self):
        """Test convenience class method for file upload success."""
        http_response = AttributeResponseBuilder.create_upload_success_response(
            target_selector="#file-grid",
            file_card_html="<div class='file-card'>New File</div>",
            message="Custom upload message"
        )
        
        self.assertIsInstance(http_response, HttpResponse)
        self.assertEqual(http_response.status_code, 200)
        
        response_data = json.loads(http_response.content)
        self.assertTrue(response_data[ResponseFields.SUCCESS])
        self.assertEqual(response_data[ResponseFields.MESSAGE], "Custom upload message")
        self.assertEqual(len(response_data[ResponseFields.UPDATES]), 1)
        self.assertEqual(response_data[ResponseFields.UPDATES][0][ResponseFields.TARGET], "#file-grid")
        self.assertEqual(response_data[ResponseFields.UPDATES][0][ResponseFields.MODE], "append")

    def test_builder_create_upload_success_response_default_message(self):
        """Test upload success response uses default message."""
        http_response = AttributeResponseBuilder.create_upload_success_response(
            target_selector="#file-grid",
            file_card_html="<div class='file-card'>File</div>"
        )
        
        response_data = json.loads(http_response.content)
        self.assertEqual(response_data[ResponseFields.MESSAGE], DefaultMessages.UPLOAD_SUCCESS)


class TestResponseHelpersEdgeCases(TestCase):
    """Test edge cases and error conditions - robustness testing."""

    def test_dom_update_empty_strings(self):
        """Test DOMUpdate handles empty strings gracefully."""
        update = DOMUpdate(target="", html="", mode=UpdateMode.REPLACE)
        result = update.to_dict()
        
        self.assertEqual(result[ResponseFields.TARGET], "")
        self.assertEqual(result[ResponseFields.HTML], "")

    def test_attribute_response_empty_message_serialization(self):
        """Test AttributeResponse handles empty message correctly."""
        response = AttributeResponse(success=True, message="")
        result = response.to_dict()
        
        # Empty message should be excluded (falsy values are filtered out)
        self.assertNotIn(ResponseFields.MESSAGE, result)

    def test_builder_multiple_build_calls_isolation(self):
        """Test builder builds independent response objects."""
        builder = AttributeResponseBuilder().success().with_message("Test")
        
        response1 = builder.build()
        response2 = builder.build()
        
        # Should be different objects
        self.assertIsNot(response1, response2)
        # But with same content
        self.assertEqual(response1.success, response2.success)
        self.assertEqual(response1.message, response2.message)

    def test_builder_state_persistence_across_builds(self):
        """Test builder state persists across multiple builds."""
        builder = (AttributeResponseBuilder()
                   .success()
                   .add_update("#element", "<div>content</div>")
                   .with_message("Persistent message"))
        
        response1 = builder.build()
        response2 = builder.build()
        
        # Both responses should have the same configuration
        self.assertTrue(response1.success)
        self.assertTrue(response2.success)
        self.assertEqual(response1.message, response2.message)
        self.assertEqual(len(response1.updates), 1)
        self.assertEqual(len(response2.updates), 1)

    def test_response_json_special_characters(self):
        """Test response handles JSON special characters correctly."""
        update = DOMUpdate(
            target="#test-element", 
            html="<div>Content with \"quotes\" and 'apostrophes' and \\ backslashes</div>"
        )
        response = AttributeResponse(success=True, updates=[update])
        
        # Should not raise exception during serialization
        http_response = response.to_http_response()
        
        # Should be valid JSON
        response_data = json.loads(http_response.content)
        expected_html = "<div>Content with \"quotes\" and 'apostrophes' and \\ backslashes</div>"
        self.assertEqual(
            response_data[ResponseFields.UPDATES][0][ResponseFields.HTML], 
            expected_html
        )