Task results and status in Django - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output of this Django view when a task is completed?

Consider a Django view that checks a task's status and returns a message accordingly.

from django.http import JsonResponse
from django.views import View

class TaskStatusView(View):
    def get(self, request, task_id):
        task = get_task_by_id(task_id)  # Returns a dict with 'status'
        if task['status'] == 'completed':
            return JsonResponse({'result': 'Task finished successfully'})
        else:
            return JsonResponse({'result': 'Task still running'})

What will be the JSON response if task['status'] is 'completed'?

Django

from django.http import JsonResponse
from django.views import View

class TaskStatusView(View):
    def get(self, request, task_id):
        task = {'status': 'completed'}
        if task['status'] == 'completed':
            return JsonResponse({'result': 'Task finished successfully'})
        else:
            return JsonResponse({'result': 'Task still running'})

A {"status": "completed"}

B {"result": "Task still running"}

C {"error": "Task not found"}

D {"result": "Task finished successfully"}

💡 Hint

Check the condition that matches the task status.

The view returns a JSON response with {'result': 'Task finished successfully'} when the task status is 'completed'.

❓ state_output

intermediate

What is the value of task_status after running this Django signal handler?

Given this Django signal handler that updates a task's status after completion:

from django.dispatch import receiver
from django.db.models.signals import post_save

@receiver(post_save, sender=Task)
def update_task_status(sender, instance, **kwargs):
    if instance.is_finished:
        instance.status = 'completed'
        instance.save()

# Assume a Task instance with is_finished=True and initial status='pending'

What will be the status of the task after the signal runs?

Django

class Task:
    def __init__(self, is_finished, status):
        self.is_finished = is_finished
        self.status = status
    def save(self):
        pass

task = Task(is_finished=True, status='pending')
if task.is_finished:
    task.status = 'completed'
    task.save()
task_status = task.status

A failed

B pending

C completed

D None

💡 Hint

Check what happens when is_finished is True.

The signal sets the status to 'completed' if is_finished is True, so the final status is 'completed'.

📝 Syntax

advanced

Which option correctly defines a Django model field to track task status with choices?

You want to define a Django model field status that only allows 'pending', 'running', or 'completed'. Which code snippet is correct?

A status = models.CharField(max_length=10, choices=('pending', 'running', 'completed'))

B status = models.CharField(max_length=10, choices=[('pending', 'Pending'), ('running', 'Running'), ('completed', 'Completed')])

C status = models.CharField(max_length=10, choices={'pending': 'Pending', 'running': 'Running', 'completed': 'Completed'})

D status = models.CharField(max_length=10, choices=[('pending'), ('running'), ('completed')])

💡 Hint

Choices must be a list of tuples pairing database value and human-readable name.

Option B correctly uses a list of tuples for choices. Option B uses a dict which is invalid. Option B uses a tuple of strings without pairs. Option B uses a list of strings without tuples.

🔧 Debug

advanced

Why does this Django async task status check raise an error?

Given this async function to check a task status:

async def check_task_status(task_id):
    task = Task.objects.get(id=task_id)
    if task.status == 'completed':
        return 'Done'
    else:
        return 'In progress'

When called in an async context, it raises an error. Why?

A Django ORM methods like get() are synchronous and cannot be awaited in async functions

B The function is missing an await keyword before Task.objects.get()

C The task.status field is not accessible in async functions

D Async functions cannot return strings in Django

💡 Hint

Consider how Django ORM works with async code.

Django ORM methods like get() are synchronous and block the event loop if called in async functions without special async ORM support.

🧠 Conceptual

expert

Which Django feature best tracks task results and status asynchronously?

You want to run long tasks in the background and check their status and results later in Django. Which feature is best suited for this?

A Using Celery with Django to run tasks asynchronously and store results

B Using Django middleware to intercept and track task status

C Using Django Channels to handle WebSocket connections for task updates

D Using Django's built-in management commands to run tasks synchronously

💡 Hint

Think about background task queues and result storage.

Celery integrates with Django to run tasks asynchronously and track their status and results efficiently.

Practice

1. In Django with Celery, which object do you use to check the status and result of a background task by its ID?

easy

A. AsyncResult

B. TaskStatus

C. TaskResult

D. ResultChecker

Solution

1. Step 1: Identify the object for task tracking

   Celery provides AsyncResult to track task status and results using the task ID.

2. Step 2: Confirm usage in Django context

   In Django projects using Celery, AsyncResult is the standard way to check if a task is pending, running, or finished.

3. Final Answer:

   AsyncResult -> Option A

4. Quick Check:

   Task status and results = AsyncResult [OK]

Hint: Remember: AsyncResult tracks task status by ID [OK]

Common Mistakes:

• Confusing AsyncResult with task function names
• Using non-existent classes like TaskStatus
• Trying to access results directly without AsyncResult

2. Which of the following is the correct way to create an AsyncResult instance for a task with ID stored in task_id?

easy

A. result = AsyncResult(task=task_id)

B. result = AsyncResult.get(task_id)

C. result = AsyncResult.fetch(task_id)

D. result = AsyncResult(task_id)

Solution

1. Step 1: Recall AsyncResult constructor usage

   The AsyncResult class is instantiated by passing the task ID as the first argument.

2. Step 2: Check each option's syntax

   Only AsyncResult(task_id) correctly creates the instance. Methods like .get() or .fetch() are not constructors.

3. Final Answer:

   result = AsyncResult(task_id) -> Option D

4. Quick Check:

   Instantiate AsyncResult with task ID directly [OK]

Hint: Use AsyncResult(task_id) to create result object [OK]

Common Mistakes:

• Calling get() or fetch() as constructor
• Passing keyword argument 'task' instead of positional
• Confusing AsyncResult with task function calls

3. Given the code:

result = AsyncResult('abc123')
status = result.status
output = result.result

What will status and output represent if the task is still running?

medium

A. status is 'PENDING', output is None

B. status is 'RUNNING', output is None

C. status is 'FAILURE', output is the error info

D. status is 'SUCCESS', output is the task result

Solution

1. Step 1: Understand AsyncResult status values

   By default, while a task is running without calling update_state inside the task, result.status remains 'PENDING'.

2. Step 2: Check result property during running

   result.result returns None until the task completes.

3. Final Answer:

   status is 'PENDING', output is None -> Option A

4. Quick Check:

   Running task (default): status='PENDING', result=None [OK]

Hint: Default running tasks show status 'PENDING' and result None [OK]

Common Mistakes:

• Mistaking for 'RUNNING' status (doesn't exist)
• Confusing with 'STARTED' which requires explicit update_state
• Thinking result is available before completion

4. You wrote:

result = AsyncResult(task_id)
if result.status == 'SUCCESS':
    print(result.result)
else:
    print('Task not done')

But it always prints 'Task not done' even after task completion. What is the likely issue?

medium

A. You must call result.get() instead of accessing result.result

B. You should check for 'COMPLETED' instead of 'SUCCESS'

C. The task ID is incorrect or expired

D. AsyncResult does not have a status attribute

Solution

1. Step 1: Understand status checking logic

   The code checks if result.status equals 'SUCCESS' to print the result.

2. Step 2: Identify why status never shows 'SUCCESS'

   If the task ID is wrong or expired, AsyncResult will not find the task and status stays 'PENDING' or similar.

3. Final Answer:

   The task ID is incorrect or expired -> Option C

4. Quick Check:

   Wrong task ID causes status never to be 'SUCCESS' [OK]

Hint: Check task ID validity if status never changes [OK]

Common Mistakes:

• Using wrong status string like 'COMPLETED'
• Assuming result.result always updates without completion
• Ignoring task ID correctness

5. You want to handle a task result in Django only if it succeeded, otherwise log the error. Which code snippet correctly checks the task status and safely accesses the result or error?

hard

A. result = AsyncResult(task_id)
if result.ready():
handle(result.result)
else:
log_error('Task not ready')

B. result = AsyncResult(task_id)
try:
handle(result.get(timeout=1))
except Exception as e:
log_error(e)

C. result = AsyncResult(task_id)
if result.status == 'PENDING':
handle(result.result)
else:
log_error('Task failed')

D. result = AsyncResult(task_id)
if result.status == 'SUCCESS':
handle(result.result)
elif result.status == 'FAILURE':
log_error(result.get())

Solution

1. Step 1: Understand safe result retrieval

   Using result.get() with a timeout waits for completion and raises exceptions on failure.

2. Step 2: Check error handling approach

   Wrapping result.get() in try-except catches task failures and allows logging errors safely.

3. Step 3: Compare other options

   Options B, C, and D do not handle exceptions properly; C incorrectly treats 'PENDING' as success.

4. Final Answer:

   Use try-except with result.get() to handle success and failure -> Option B

5. Quick Check:

   Use result.get() with try-except for safe task result handling [OK]

Hint: Use try-except with result.get() to catch errors [OK]

Common Mistakes:

• Checking only status strings without exception handling
• Assuming ready() means success
• Treating PENDING as success