Testing API Endpoints with Postman

1. The Browsable API: Your First Line of Defense

You've already seen the Browsable API in action. It's the user-friendly HTML interface that DRF provides when you access your endpoints in a web browser. While it's not how a real application (like a JavaScript frontend) would consume your API, it's an incredibly convenient tool for quick, on-the-fly testing during development.

Let's start with a quick video that shows how you can interact with it.

Now that you have a visual, let's dive deeper with a more structured guide. The following article from TestDriven.io provides an excellent walkthrough of manually testing an API, starting with the Browsable API.

Your Turn: Test Your Task Endpoints

With your development server running (python manage.py runserver), open your browser and put the Browsable API to the test on your own project:

1. Navigate to the API root: Go to http://127.0.0.1:8000/api/. You should see the entry for your tasks endpoint that the DefaultRouter created.
2. Test GET (list) and POST: Click the link to go to /api/tasks/.
   • You'll see a list of any tasks you've already created.
   • Scroll down to the HTML form. Use it to create a new task by filling in the title and description and clicking POST. The new task should appear in the list above.
3. Test GET (detail), PUT, and DELETE: From the task list, click the link for the task you just created (e.g., /api/tasks/1/).
   • You are now on the detail view for that single task.
   • Use the HTML form to update the task (this performs a PUT request).
   • Finally, click the red DELETE button to remove the task.

The Browsable API is fantastic for this kind of quick verification. However, to truly simulate how another program would interact with your API, we need a more powerful tool.

2. Professional API Testing with Postman

Postman is an application designed specifically for API testing. It acts as a true API client, allowing you to craft raw HTTP requests (GET, POST, PUT, etc.), set headers, and send data in formats like JSON. The response you get back is exactly what a front-end application would receive. This makes it an essential tool for backend development.

If you don't have it installed, please download and install Postman now.

Let's watch a demonstration of how to use Postman to test the five main types of API requests.

Now, let's use the same article from before, which also has a fantastic, detailed guide to using Postman. We'll use it to test our Task API.

Step-by-Step with Postman and Your Task API

Let's follow the steps from the article and apply them to your Task endpoints.

1. GET (list)

• In Postman, create a new request.
• Set the method to GET.
• Enter the URL: http://127.0.0.1:8000/api/tasks/
• Click "Send". You should see a JSON array of your tasks in the response body.

2. POST (create)

• Change the method to POST.
• Go to the Body tab, select raw, and choose JSON from the dropdown.
• Enter the JSON for a new task. Remember, id and created are handled by the server.
  json { "title": "Learn Postman", "description": "Test the API for my task manager project.", "completed": false }
• Click "Send". You should get a 201 Created status and see the newly created task in the response.

3. GET (detail)

• Change the method back to GET.
• Append the ID of the task you just created to the URL: http://127.0.0.1:8000/api/tasks/<your_task_id>/.
• Click "Send". You'll get the JSON object for that single task.

4. PUT vs. PATCH (update)

• PUT (Full Update): Change the method to PUT. In the Body (raw, JSON), you must provide all the required fields for the object.
  json { "title": "Master Postman", "description": "Test the PUT method for the API.", "completed": true }
• PATCH (Partial Update): Change the method to PATCH. Now you only need to send the field(s) you want to change.
  json { "completed": false }
• Send each request (to the detail URL) and observe the updated object in the response.

5. DELETE

• Change the method to DELETE.
• Use the same detail URL: http://127.0.0.1:8000/api/tasks/<your_task_id>/.
• No body is needed. Click "Send".
• You should receive a 204 No Content status code, and the response body will be empty. If you now try to do a GET request for that ID, you should get a 404 Not Found.

Conclusion

Great job! You've successfully tested your API both as a developer with the convenient Browsable API and as a client with the more realistic Postman. This manual testing process is fundamental to API development, ensuring your backend logic is solid before connecting it to anything else.

Key Takeaways:

• The Browsable API is a fantastic tool for quick, human-readable feedback during development.
• Postman simulates a real API client, allowing you to craft precise HTTP requests and inspect raw JSON responses. It's the standard for thorough manual API testing.
• The five core HTTP methods map directly to CRUD operations:
  • GET: Retrieve data (list or detail).
  • POST: Create new data.
  • PUT: Replace an existing resource completely.
  • PATCH: Partially update an existing resource.
  • DELETE: Remove a resource.

Preview of the Next Lesson:

Manual testing is essential, but it can become repetitive and time-consuming as your application grows. What if you could automate this process? In our next lesson, we will explore the importance of automated testing and learn how to write unit tests for our Django application. This will allow us to verify our models, views, and API logic automatically every time we make a change, giving us confidence that our code is always working correctly.