def test_worker_controller_recursion_bug(self, patching):
        """Test that creating WorkController doesn't cause infinite recursion.
        
        Regression test for the issue where:
        1. DjangoFixup.install() registers on_import_modules and on_worker_init signals
        2. WorkController.__init__ is called (from bin.worker)
        3. on_import_modules callback runs and accesses worker_fixup property
        4. worker_fixup property creates DjangoWorkerFixup without a worker
        5. DjangoWorkerFixup.__init__ creates a NEW WorkController(app)
        6. This new WorkController sends worker_init signal
        7. on_worker_init callback runs and accesses worker_fixup again
        8. Since worker_fixup is still None (step 4 hasn't finished), it creates another
        9. Infinite recursion -> RecursionError
        
        Additionally, this causes pool_cls to be a string instead of a class,
        leading to AttributeError when trying to access pool_cls.__module__
        """
        from celery import signals
        from celery.worker import WorkController
        
        patching('celery.fixups.django.symbol_by_name')
        patching('celery.fixups.django.import_module')
        patching.modules('django', 'django.db', 'django.core.checks')
        patching.setenv('DJANGO_SETTINGS_MODULE', 'settings')
        
        # Create and install DjangoFixup
        django_fixup = DjangoFixup(self.app)
        django_fixup.install()
        
        # Track how many times WorkController is instantiated
        original_init = WorkController.__init__
        instantiation_count = {'count': 0}
        recursion_errors = []
        attribute_errors = []
        
        def tracked_init(self_worker, *args, **kwargs):
            instantiation_count['count'] += 1
            # Prevent actual infinite recursion in test by limiting
            if instantiation_count['count'] > 5:
                raise RecursionError("Too many WorkController instantiations detected")
            return original_init(self_worker, *args, **kwargs)
        
        # Capture signal errors
        def signal_error_handler(sender, **kwargs):
            exc = kwargs.get('exception')
            if isinstance(exc, RecursionError):
                recursion_errors.append(exc)
            elif isinstance(exc, AttributeError) and "'str' object has no attribute '__module__'" in str(exc):
                attribute_errors.append(exc)
        
        signals.worker_init.connect(signal_error_handler, weak=False)
        
        try:
            with patch.object(WorkController, '__init__', tracked_init):
                # Simulate what happens in celery.bin.worker
                try:
                    worker = WorkController(
                        app=self.app,
                        hostname='testworker@localhost',
                        pool_cls='solo',
                        loglevel='INFO',
                    )
                except (RecursionError, AttributeError, TypeError):
                    # These exceptions may bubble up or be caught by signal handlers
                    pass
        finally:
            signals.worker_init.disconnect(signal_error_handler)
        
        # Verify that multiple WorkController instances were created (recursion happened)
        assert instantiation_count['count'] > 1, \
            f"Expected multiple WorkController instantiations due to recursion bug, got {instantiation_count['count']}"
        
        # The test confirms the bug exists: multiple WorkController instantiations occur
        # when only one should be created