Skip to content

Home Information - Your home, your data, organized.

Python
14.4 KB
Raw Blame
"""
View integration tests for attribute editing workflows.

Tests complete request/response cycles for entity attribute editing,
including handler/renderer integration, session dependencies, and
antinode response patterns.
"""
import logging
from django.urls import reverse

from hi.apps.entity.tests.synthetic_data import EntityAttributeSyntheticData
from hi.apps.entity.models import EntityAttribute
from hi.apps.attribute.enums import AttributeType
from hi.enums import ViewMode
from hi.testing.view_test_base import DualModeViewTestCase

logging.disable(logging.CRITICAL)


class TestEntityAttributeViewIntegration(DualModeViewTestCase):
    """Test complete entity attribute editing workflows - end-to-end integration."""
    
    def setUp(self):
        super().setUp()
        self.enterContext(self.in_memory_media_storage())
        
        # Create entity with attributes for testing
        self.entity = EntityAttributeSyntheticData.create_test_entity(
            name="Test Entity Integration"
        )
        
        # Create various attribute types for comprehensive testing
        self.text_attr = EntityAttributeSyntheticData.create_test_text_attribute(
            entity=self.entity,
            name="description",
            value="Original description"
        )
        
        self.secret_attr = EntityAttributeSyntheticData.create_test_secret_attribute(
            entity=self.entity,
            name="api_key",
            value="secret_key_123"
        )
        
        self.file_attr = EntityAttributeSyntheticData.create_test_file_attribute(
            entity=self.entity,
            name="manual",
            value="Device Manual"
        )
        
        # Set required session state for views
        self.setSessionViewMode(ViewMode.EDIT)
    
    def test_entity_edit_view_get_request_success(self):
        """Test GET request to entity edit view returns correct template and context - initial rendering."""
        url = reverse('entity_edit', kwargs={'entity_id': self.entity.id})
        response = self.client.get(url)
        
        self.assertSuccessResponse(response)
        self.assertHtmlResponse(response)
        
        # Should have entity and forms in context
        self.assertEqual(response.context['entity'], self.entity)
        self.assertIn('entity_form', response.context)
        self.assertIn('regular_attributes_formset', response.context)
        self.assertIn('file_attributes', response.context)
        
        # Should have AttributeItemEditContext integration
        self.assertIn('attr_item_context', response.context)
        attr_item_context = response.context['attr_item_context']
        
        from hi.apps.entity.entity_attribute_edit_context import EntityAttributeItemEditContext
        self.assertIsInstance(attr_item_context, EntityAttributeItemEditContext)
        self.assertEqual(attr_item_context.entity, self.entity)
        
    def test_entity_edit_view_ajax_get_request(self):
        """Test AJAX GET request returns JSON response - async rendering."""
        url = reverse('entity_edit', kwargs={'entity_id': self.entity.id})
        response = self.async_get(url)
        
        self.assertSuccessResponse(response)
        self.assertJsonResponse(response)
        
        # Should contain fragment data for antinode (modal or insert_map structure)
        data = response.json()
        # Response may have 'modal' or other antinode structure, not necessarily 'fragments'
        self.assertTrue(isinstance(data, dict) and len(data) > 0)
        
    def test_entity_edit_view_post_valid_data_success(self):
        """Test POST request with valid data saves successfully - complete workflow."""
        url = reverse('entity_edit', kwargs={'entity_id': self.entity.id})
        
        # Create valid form data
        form_data = EntityAttributeSyntheticData.create_form_data_for_entity_edit(
            self.entity,
            name="Updated Entity Name"
        )
        
        response = self.client.post(url, form_data)
        
        # Should redirect to success or return success response
        self.assertTrue(response.status_code in [200, 302])
        
        # Entity should be updated
        self.entity.refresh_from_db()
        self.assertEqual(self.entity.name, "Updated Entity Name")
        
    def test_entity_edit_view_post_invalid_data_error(self):
        """Test POST request with invalid data returns error response - error handling workflow."""
        url = reverse('entity_edit', kwargs={'entity_id': self.entity.id})
        
        # Create invalid form data (empty name)
        form_data = EntityAttributeSyntheticData.create_form_data_for_entity_edit(
            self.entity,
            name=""  # Invalid empty name
        )
        
        response = self.client.post(url, form_data)
        
        # Should return error response (400 for invalid form data)
        self.assertErrorResponse(response)
        
        # Entity should not be updated
        original_name = self.entity.name
        self.entity.refresh_from_db()
        self.assertEqual(self.entity.name, original_name)
        
    def test_entity_edit_view_ajax_post_valid_data(self):
        """Test AJAX POST request with valid data returns JSON success - async workflow."""
        url = reverse('entity_edit', kwargs={'entity_id': self.entity.id})
        
        form_data = EntityAttributeSyntheticData.create_form_data_for_entity_edit(
            self.entity,
            name="AJAX Updated Name"
        )
        
        response = self.async_post(url, form_data)
        
        self.assertSuccessResponse(response)
        self.assertJsonResponse(response)
        
        # Should contain antinode response data
        data = response.json()
        self.assertTrue(isinstance(data, dict) and len(data) > 0)
        
        # Entity should be updated
        self.entity.refresh_from_db()
        self.assertEqual(self.entity.name, "AJAX Updated Name")
        
    def test_entity_edit_view_ajax_post_invalid_data(self):
        """Test AJAX POST request with invalid data returns JSON error - async error workflow."""
        url = reverse('entity_edit', kwargs={'entity_id': self.entity.id})
        
        form_data = EntityAttributeSyntheticData.create_form_data_for_entity_edit(
            self.entity,
            name=""  # Invalid
        )
        
        response = self.async_post(url, form_data)
        
        # Should return error response (400)
        self.assertErrorResponse(response)
        self.assertJsonResponse(response)
        
    def test_entity_attribute_formset_creation_workflow(self):
        """Test attribute formset creation and updates - formset integration."""
        url = reverse('entity_edit', kwargs={'entity_id': self.entity.id})
        
        # Get initial form data
        form_data = EntityAttributeSyntheticData.create_form_data_for_entity_edit(self.entity)
        
        # Add new attribute to formset
        prefix = f'entity-{self.entity.id}'
        form_data.update({
            f'{prefix}-TOTAL_FORMS': '2',  # Existing + 1 new
            f'{prefix}-INITIAL_FORMS': '1',  # Only the existing text_attr
            f'{prefix}-1-name': 'new_property',
            f'{prefix}-1-value': 'new value',
            f'{prefix}-1-attribute_type_str': str(AttributeType.CUSTOM),
        })
        
        response = self.client.post(url, form_data)
        
        # Should succeed
        self.assertTrue(response.status_code in [200, 302])
        
        # New attribute should be created
        new_attr = EntityAttribute.objects.filter(
            entity=self.entity,
            name='new_property'
        ).first()
        self.assertIsNotNone(new_attr)
        self.assertEqual(new_attr.value, 'new value')
        
    def test_file_deletion_workflow(self):
        """Test file attribute deletion workflow - file operation integration."""
        url = reverse('entity_edit', kwargs={'entity_id': self.entity.id})
        
        # Create form data with file deletion
        form_data = EntityAttributeSyntheticData.create_form_data_for_entity_edit(self.entity)
        form_data['delete_file_attribute'] = [str(self.file_attr.id)]
        
        response = self.client.post(url, form_data)
        
        # Should succeed
        self.assertTrue(response.status_code in [200, 302])
        
        # File attribute should be deleted
        self.assertFalse(EntityAttribute.objects.filter(id=self.file_attr.id).exists())
        
    def test_file_title_update_workflow(self):
        """Test file title update workflow - file metadata workflow."""
        url = reverse('entity_edit', kwargs={'entity_id': self.entity.id})
        
        # Create form data with file title update
        form_data = EntityAttributeSyntheticData.create_form_data_for_entity_edit(self.entity)
        file_title_updates = EntityAttributeSyntheticData.create_file_title_update_data(
            self.entity, [self.file_attr]
        )
        form_data.update(file_title_updates)
        
        response = self.client.post(url, form_data)
        
        # Should succeed
        self.assertTrue(response.status_code in [200, 302])
        
        # File attribute title should be updated
        self.file_attr.refresh_from_db()
        self.assertEqual(self.file_attr.value, f'Updated {self.file_attr.name}')
        
    def test_session_dependency_integration(self):
        """Test view dependencies on session state - middleware integration."""
        # Test without required session state
        session = self.client.session
        if 'view_mode' in session:
            del session['view_mode']
        session.save()
        
        url = reverse('entity_edit', kwargs={'entity_id': self.entity.id})
        response = self.client.get(url)
        
        # Response depends on view implementation - might redirect or show different content
        # The important thing is it doesn't crash
        self.assertIsInstance(response.status_code, int)
        
    def test_attribute_context_template_integration(self):
        """Test AttributeItemEditContext integration with actual templates - template rendering."""
        url = reverse('entity_edit', kwargs={'entity_id': self.entity.id})
        response = self.client.get(url)
        
        self.assertSuccessResponse(response)
        
        # Response should include AttributeItemEditContext data
        context = response.context
        self.assertIn('attr_item_context', context)
        
        attr_item_context = context['attr_item_context']
        
        # Should provide all the template functionality
        self.assertEqual(attr_item_context.owner_type, 'entity')
        self.assertEqual(attr_item_context.owner_id, self.entity.id)
        
        # Template should be able to use these patterns
        history_id = attr_item_context.history_target_id(123)
        self.assertIn('hi-entity-attr-history', history_id)
        
    def test_error_handling_integration(self):
        """Test error handling across the full stack - comprehensive error handling."""
        url = reverse('entity_edit', kwargs={'entity_id': self.entity.id})
        
        # Create data that will cause multiple types of errors
        form_data = {
            'name': '',  # Required field error
            f'entity-{self.entity.id}-TOTAL_FORMS': '1',
            f'entity-{self.entity.id}-INITIAL_FORMS': '0',
            f'entity-{self.entity.id}-MIN_NUM_FORMS': '0',
            f'entity-{self.entity.id}-MAX_NUM_FORMS': '1000',
            f'entity-{self.entity.id}-0-name': '',  # Attribute name error
            f'entity-{self.entity.id}-0-value': '',  # Attribute value error
        }
        
        response = self.client.post(url, form_data)
        
        # Should handle errors gracefully with 400 status
        self.assertErrorResponse(response)
        
        # Should show form with errors
        if hasattr(response, 'context') and response.context:
            context = response.context
            # Form should have errors
            if 'entity_form' in context:
                entity_form = context['entity_form']
                # Form validation depends on actual form implementation
                self.assertTrue(hasattr(entity_form, 'errors'))
                
    def test_nonexistent_entity_handling(self):
        """Test handling of requests for nonexistent entities - error boundary testing."""
        nonexistent_id = 999999
        url = reverse('entity_edit', kwargs={'entity_id': nonexistent_id})
        
        response = self.client.get(url)
        
        # Should return 404 or redirect
        self.assertTrue(response.status_code in [404, 302])
        
    def test_concurrent_edit_handling(self):
        """Test handling of concurrent edits - data consistency testing."""
        url = reverse('entity_edit', kwargs={'entity_id': self.entity.id})
        
        # Modify entity outside of the form
        self.entity.name = "Externally Modified"
        self.entity.save()
        
        # Submit form with old data
        form_data = EntityAttributeSyntheticData.create_form_data_for_entity_edit(
            self.entity,
            name="Form Modified"  # Different from external modification
        )
        
        response = self.client.post(url, form_data)
        
        # Should handle gracefully (exact behavior depends on implementation)
        self.assertIsInstance(response.status_code, int)
        
        # Final state should be consistent
        self.entity.refresh_from_db()
        self.assertIsInstance(self.entity.name, str)
        self.assertTrue(len(self.entity.name) > 0)
        
    def test_view_mode_switching_integration(self):
        """Test view behavior with different view modes - UI state integration."""
        url = reverse('entity_edit', kwargs={'entity_id': self.entity.id})
        
        # Test with different view modes
        view_modes = [ViewMode.EDIT]  # Only test modes that exist
        
        for mode in view_modes:
            with self.subTest(view_mode=mode):
                self.setSessionViewMode(mode)
                
                response = self.client.get(url)
                
                # Should handle different modes appropriately
                self.assertIsInstance(response.status_code, int)
                
                # Context should reflect the view mode
                if response.status_code == 200 and hasattr(response, 'context'):
                    # Exact behavior depends on view implementation
                    self.assertIsNotNone(response.context)