Introduction

In this final section, we’ll master GitHub Copilot’s core features and apply them to build a small, practical project that solves a real compliance need. In this lesson we will:

Introduce the project and requirements.
Create a new Python project.
Build a fake-data generator API with inline code documentation.
Add unit tests to verify behavior.
Produce API documentation so others can use the tool.
Demonstrate how AI pair-programming fits into the workflow.

Your company requirement is simple but strict: you may no longer use real customer data for testing. Customer privacy must be protected at all times.

Do not use, copy, or expose any real customer PII in development, test environments, or CI logs. This project provides safe, realistic mock data so teams can validate behavior without risking compliance violations.

A slide titled "What We'll Build" showing a person/documents icon on the left with a red X over "Customer Data." An arrow leads to a computer screen labeled "Software Testing" with gears indicating configuration or automation.

We don’t need real data to validate functionality. Instead, we’ll build a fake-data generator that produces realistic mock records so developers and testers can exercise applications without exposing customer information. Project summary

Goal: Create an API that returns realistic mock user data in multiple formats (JSON, CSV, downloadable text files).
Stack: FastAPI (Python), pytest (unit testing), and standard libraries for serialization.
Outputs: Configurable fake records for frontend, batch processing, and download pipelines.

Why this helps

Preserves privacy and regulatory compliance.
Allows deterministic testing by using optional seeding for reproducible results.
Makes it easy for teams to integrate mock data into automated tests and examples.

What we’ll build

A small FastAPI service with an endpoint such as POST /api/v1/getfakedata that accepts a JSON payload describing the count and format.
Format options: json, csv, text (downloadable).
Inline code documentation and OpenAPI (automatic) documentation for discoverability.

Example JSON response

[
  {
    "first_name": "Catherine",
    "last_name": "Parker",
    "email_address": "catherine.parker@example.com",
    "age": 27,
    "city": "Austin",
    "occupation": "Graphic Designer"
  },
  {
    "first_name": "Ethan",
    "last_name": "Roberts",
    "email_address": "ethanroberts@fakemail.com",
    "age": 26,
    "city": "Denver",
    "occupation": "Photographer"
  }
]

Quick reference — project deliverables

Component	Purpose	Example / Notes
API endpoint	Provide mock records	`POST /api/v1/getfakedata`
Request body	Specify count, format, optional seed	`{ "count": 100, "format": "csv", "seed": 42 }`
Serialization	Return JSON, CSV, or downloadable text	JSON/CSV streaming or `FileResponse` for downloads
Tests	Ensure deterministic behavior	Use `pytest` and `starlette.testclient`
Docs	Auto-generated OpenAPI docs	FastAPI provides `/docs` and `/redoc`

Example unit test

This test demonstrates patching the data fetcher and verifying the endpoint response.

def test_get_fake_data_endpoint_success(sample_data):
    """Test successful API endpoint call."""
    with patch("app.main.fetch_fake_data", return_value=sample_data):
        response = client.post("/api/v1/getfakedata", json={"count": 2})

    assert response.status_code == 200
    assert len(response.json()) == 2
    assert response.json() == sample_data

Implementation notes and best practices

Use FastAPI’s dependency injection to separate data generation from request handling; this makes testing and mocking straightforward.
Support a seed parameter to produce repeatable pseudo-random datasets for CI tests.
Keep fake data schema consistent (field names, types) so downstream systems can rely on stable shapes.
For large exports, stream CSV to avoid memory pressure.

Testing and documentation

Unit tests: use pytest + TestClient from FastAPI / Starlette; patch data generation functions to focus tests on routing and serialization.
Integration tests: run the real generator with a fixed seed and validate schema and sample values.
API docs: FastAPI exposes OpenAPI documentation at /docs and /redoc; add clear example payloads and response models.
CI: include tests and basic linting steps to ensure the fake-data generator remains reliable as it evolves.

GitHub Copilot Basics

Prompt Engineering with Copilot

Advanced Features

Management of GitHub Copilot

Using Copilot Efficiently

Introduction

Watch Video