Realistic test assignment for Junior Python developer | FastAPI + GraphQL

In this tutorial, we will walk through a real test task for a Junior Python developer focusing on FastAPI and GraphQL. FastAPI is a modern, fast web framework for building APIs with Python 3.6+ based on standard Python type hints. GraphQL is a query language for your API and a runtime for executing those queries by using a type system that you define for your data.

The test task we will cover involves creating a simple CRUD API using FastAPI and GraphQL. The task includes the following requirements:

1. Create a user model with the following fields: id, name, email.
2. Implement CRUD operations for the user model using GraphQL.
3. Users should be able to query all users, query a specific user by id, create a new user, update an existing user, and delete a user.

Let’s start by setting up our project and installing the necessary dependencies. We will need to install FastAPI, graphene, and uvicorn.

pip install fastapi graphene uvicorn

Next, let’s create a new Python file for our project, for example, app.py. We will start by importing the necessary modules and creating the user model.

from typing import List
from fastapi import FastAPI
from pydantic import BaseModel
from graphene import ObjectType, String, ID, List as GrapheneList, Field
from fastapi_graphql import GraphQLApp

app = FastAPI()

class User(BaseModel):
    id: int
    name: str
    email: str

users = []

Next, we will define the GraphQL schema for our API. We will create a User schema with queries and mutations for CRUD operations.

class UserSchema(ObjectType):
    id = ID()
    name = String()
    email = String()

class Query(ObjectType):
    users = GrapheneList(UserSchema)

    def resolve_users(self, info):
        return users

class CreateUser(ObjectType):
    user = Field(UserSchema)

class CreateUserInput(BaseModel):
    name: str
    email: str

class CreateMutation(ObjectType):
    create_user = Field(CreateUser, input=CreateUserInput)

    def resolve_create_user(self, info, input):
        new_user = User(id=len(users) + 1, name=input.name, email=input.email)
        users.append(new_user)
        return CreateUser(user=new_user)

class UpdateUser(ObjectType):
    user = Field(UserSchema)

class UpdateUserInput(BaseModel):
    id: int
    name: str
    email: str

class UpdateMutation(ObjectType):
    update_user = Field(UpdateUser, input=UpdateUserInput)

    def resolve_update_user(self, info, input):
        user = next((user for user in users if user.id == input.id), None)
        if user:
            user.name = input.name
            user.email = input.email
        return UpdateUser(user=user)

class DeleteUser(ObjectType):
    success = String()

class DeleteUserInput(BaseModel):
    id: int

class DeleteMutation(ObjectType):
    delete_user = Field(DeleteUser, input=DeleteUserInput)

    def resolve_delete_user(self, info, input):
        user = next((user for user in users if user.id == input.id), None)
        if user:
            users.remove(user)
            return DeleteUser(success="User deleted successfully")
        return DeleteUser(success="User not found")

Lastly, we will create the main function that will create the FastAPI app and add the GraphQL endpoint to it.

if __name__ == "__main__":
    app.add_route("/graphql", GraphQLApp(schema=Schema(query=Query, mutation=Mutation)))
    uvicorn.run(app, host="0.0.0.0", port=8000)

Now, we can run our API by executing the following command in the terminal:

uvicorn app:app --reload

You can now test your API using a tool like Postman or GraphQL Playground. Here are some example queries you can try:

# Query all users
{
  users {
    id
    name
    email
  }
}

# Query a specific user by id
{
  user(id: 1) {
    id
    name
    email
  }
}

# Create a new user
mutation {
  createUser(input: {name: "John Doe", email: "johndoe@example.com"}) {
    user {
      id
      name
      email
    }
  }
}

# Update an existing user
mutation {
  updateUser(input: {id: 1, name: "Jane Doe", email: "janedoe@example.com"}) {
    user {
      id
      name
      email
    }
  }
}

# Delete a user
mutation {
  deleteUser(input: {id: 1}) {
    success
  }
}

Congratulations! You have successfully completed the test task for a Junior Python developer focusing on FastAPI and GraphQL. Feel free to explore more features of FastAPI and GraphQL to enhance your API further. Happy coding!