Add initial project structure with FastAPI, Docker, and SQLite integr…

.gitignore

@@ -0,0 +1,66 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Virtual environments
+venv/
+env/
+ENV/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# Database
+*.db
+*.sqlite
+*.sqlite3
+data/*.db
+data/*.sqlite
+data/*.sqlite3
+
+# Logs
+*.log
+
+# Environment variables
+.env
+.env.local
+
+# Docker
+.dockerignore
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Testes
+.pytest_cache/
+.coverage
+htmlcov/
+.tox/
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/ 

Dockerfile

@@ -0,0 +1,26 @@
+# Usar imagem oficial do Python
+FROM python:3.11-slim
+
+# Definir diretório de trabalho
+WORKDIR /app
+
+# Copiar arquivo de dependências
+COPY requirements.txt .
+
+# Instalar dependências
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copiar código da aplicação
+COPY . .
+
+# Tornar o script executável
+RUN chmod +x start.sh
+
+# Expor porta 8000
+EXPOSE 8000
+
+# Comando para executar a aplicação
+CMD ["./start.sh"]
+
+# Comando alternativo para executar testes
+# CMD ["pytest", "-v"] 

README.md

@@ -1,34 +1,245 @@
 ![WATTIO](http://wattio.com.br/web/image/1204-212f47c3/Logo%20Wattio.png)
 
-#### Descrição
+## 👨‍💻 Desenvolvedor
 
-O desafio consiste em implementar um CRUD de filmes, utilizando [python](https://www.python.org/ "python") integrando com uma API REST e uma possível persistência de dados.
+**Bruno Ricardo Alves Pultz** - Desenvolvimento completo do CRUD de filmes com FastAPI
 
-Rotas da API:
+## 📋 Sobre o Projeto
 
- - `/filmes` - [GET] deve retornar todos os filmes cadastrados.
- - `/filmes` - [POST] deve cadastrar um novo filme.
- - `/filmes/{id}` -  [GET] deve retornar o filme com ID especificado.
+Este é um fork do desafio WATT Filmes, implementando um CRUD completo com autenticação JWT, testes unitários e containerização Docker.
+
+**Repositório**: [https://github.com/BrunoPultz/watt-backend](https://github.com/BrunoPultz/watt-backend)
+
+#### Description
+
+The challenge consists of implementing a movie CRUD using [python](https://www.python.org/ "python") integrating with a REST API and possible data persistence.
+
+API Routes:
+
+- `/movies` - [GET] should return all registered movies.
+- `/movies` - [POST] should register a new movie.
+- `/movies/{id}` - [GET] should return the movie with specified ID.
 
 O Objetivo é te desafiar e reconhecer seu esforço para aprender e se adaptar. Qualquer código enviado, ficaremos muito felizes e avaliaremos com toda atenção!
 
-#### Sugestão de Ferramentas 
-Não é obrigatório utilizar todas as as tecnologias sugeridas, mas será um diferencial =]
+#### Suggested Tools
+
+It's not mandatory to use all suggested technologies, but it will be a differential =]
+
+- Object-oriented programming (use objects, classes to manipulate movies)
+- [FastAPI](https://fastapi.tiangolo.com/) (API with auto-generated documentation)
+- [Docker](https://www.docker.com/) / [Docker-compose](https://docs.docker.com/compose/install/) (Application should be in a docker container, and start should be with the command `docker-compose up`
+- Database integration (persist information in json (beginner) /[SqLite](https://www.sqlite.org/index.html) / [SQLAlchemy](https://fastapi.tiangolo.com/tutorial/sql-databases/#sql-relational-databases) / other DBs)
+
+## 🚀 How to run the application
+
+### Prerequisites
+
+- Docker and Docker Compose installed
+- Git
+
+### Steps to run
+
+1. **Clone the repository**
+
+```bash
+git clone <repository-url>
+cd watt-backend
+```
+
+2. **Run with Docker Compose**
+
+**Windows (PowerShell):**
+
+**Option 1 - Automatic script:**
+
+```powershell
+powershell -ExecutionPolicy Bypass -File run.ps1
+```
+
+**Option 2 - Manual:**
+
+```powershell
+# Add Docker to current session PATH
+$env:PATH += ";C:\Program Files\Docker\Docker\resources\bin"
+
+# Run the application
+docker compose up --build
+```
+
+**Option 3 - Full path:**
+
+```powershell
+& "C:\Program Files\Docker\Docker\resources\bin\docker.exe" compose up --build
+```
+
+**Linux/Mac:**
+
+```bash
+docker-compose up
+```
+
+3. **Access the API**
+
+- **API**: http://localhost:8000
+- **Swagger Documentation**: http://localhost:8000/docs
+- **ReDoc Documentation**: http://localhost:8000/redoc
+
+### 🎯 API Routes
+
+#### Authentication
+
+- `POST /auth/register` - Register new user
+- `POST /auth/login` - Login (returns JWT token)
+- `GET /auth/me` - View logged user data
+
+#### Users (CRUD)
+
+- `GET /users` - List all users (protected)
+- `GET /users/{id}` - View specific user (protected)
+- `PUT /users/{id}` - Update user (protected - own profile only)
+- `DELETE /users/{id}` - Remove user (protected - own profile only)
+
+#### Movies (CRUD)
+
+- `GET /movies` - List all movies (public)
+- `POST /movies` - Register new movie (protected)
+- `GET /movies/{id}` - View specific movie (public)
+- `PUT /movies/{id}` - Update movie (protected)
+- `DELETE /movies/{id}` - Remove movie (protected)
+
+### 🔐 Autenticação
+
+Para acessar rotas protegidas, use o token JWT no header:
+
+```
+Authorization: Bearer <seu-token-jwt>
+```
+
+### 📝 Exemplo de uso
+
+1. **Cadastrar usuário:**
+
+```bash
+curl -X POST "http://localhost:8000/auth/register" \
+  -H "Content-Type: application/json" \
+  -d '{"email": "[email protected]", "password": "123456", "name": "João"}'
+```
+
+2. **Fazer login:**
+
+```bash
+curl -X POST "http://localhost:8000/auth/login" \
+  -H "Content-Type: application/json" \
+  -d '{"email": "[email protected]", "password": "123456"}'
+```
+
+3. **Cadastrar filme (com token):**
+
+```bash
+curl -X POST "http://localhost:8000/movies" \
+  -H "Authorization: Bearer <seu-token>" \
+  -H "Content-Type: application/json" \
+  -d '{"title": "The Godfather", "year": 1972, "director": "Francis Ford Coppola", "genre": "Drama", "duration": 175, "rating": 9.2}'
+```
+
+4. **Listar todos os usuários (com token):**
+
+```bash
+curl -X GET "http://localhost:8000/users" \
+  -H "Authorization: Bearer <seu-token>"
+```
+
+5. **Atualizar usuário (com token):**
+
+```bash
+curl -X PUT "http://localhost:8000/users/1" \
+  -H "Authorization: Bearer <seu-token>" \
+  -H "Content-Type: application/json" \
+  -d '{"name": "João Silva", "email": "[email protected]"}'
+```
+
+6. **Deletar usuário (com token):**
+
+```bash
+curl -X DELETE "http://localhost:8000/users/1" \
+  -H "Authorization: Bearer <seu-token>"
+```
+
+### 🧪 Executando os Testes
+
+Para executar os testes unitários:
+
+```bash
+# Executar todos os testes
+pytest
+
+# Executar com mais detalhes
+pytest -v
+
+# Executar testes específicos
+pytest tests/test_auth.py
+
+# Executar com cobertura (se instalado)
+pytest --cov=app
+
+# Executar apenas testes rápidos
+pytest -m "not slow"
+```
+
+**Cobertura de Testes:**
+
+- ✅ **Rotas de Autenticação** - Registro, login, verificação de usuário
+- ✅ **Rotas de Filmes** - CRUD completo com autenticação
+- ✅ **Rotas de Usuários** - CRUD completo com proteções de segurança
+- ✅ **Operações CRUD** - Testes unitários para todas as operações
+- ✅ **Autenticação JWT** - Criação, verificação e manipulação de tokens
+- ✅ **Validação de Dados** - Schemas Pydantic e validações
+- ✅ **Segurança** - Hash de senhas, proteções de acesso
 
-- Orientação a objetos (utilizar objetos, classes para manipular os filmes)
-- [FastAPI](https://fastapi.tiangolo.com/) (API com documentação auto gerada)
-- [Docker](https://www.docker.com/) / [Docker-compose](https://docs.docker.com/compose/install/) (Aplicação deverá ficar em um container docker, e o start deverá seer com o comando ``` docker-compose up ```
-- Integração com banco de dados (persistir as informações em json (iniciante) /[SqLite](https://www.sqlite.org/index.html) / [SQLAlchemy](https://fastapi.tiangolo.com/tutorial/sql-databases/#sql-relational-databases) / outros DB)
+### 🛠️ Tecnologias utilizadas
 
+- **Python 3.11** - Linguagem principal
+- **FastAPI** - Framework web com documentação automática
+- **SQLAlchemy** - ORM para banco de dados
+- **SQLite** - Banco de dados
+- **Alembic** - Controle de versão do banco (migrações)
+- **JWT** - Autenticação com tokens
+- **Docker** - Containerização
+- **Pydantic** - Validação de dados
+- **Pytest** - Framework de testes unitários
 
-#### Como começar?
+### 📁 Estrutura do projeto
 
-- Fork do repositório
-- Criar branch com seu nome ``` git checkout -b feature/ana ```
-- Faça os commits de suas alterações ``` git commit -m "[ADD] Funcionalidade" ```
-- Envie a branch para seu repositório ``` git push origin feature/ana ```
-- Navegue até o [Github](https://github.com/), crie seu Pull Request apontando para a branch **```main```**
-- Atualize o README.md descrevendo como subir sua aplicação
+```
+watt-backend/
+├── app/
+│   ├── main.py              # Aplicação FastAPI
+│   ├── models/              # Modelos SQLAlchemy
+│   ├── schemas/             # Schemas Pydantic
+│   ├── crud/                # Operações CRUD
+│   ├── database/            # Configuração do banco
+│   ├── routes/              # Rotas da API
+│   ├── auth/                # Autenticação JWT
+│   └── middleware/          # Middleware de autenticação
+├── tests/                   # Testes unitários
+│   ├── conftest.py          # Configuração do pytest
+│   ├── test_auth.py         # Testes de autenticação
+│   ├── test_filmes.py       # Testes de filmes
+│   ├── test_usuarios.py     # Testes de usuários
+│   ├── test_crud.py         # Testes CRUD
+│   └── test_auth_jwt.py     # Testes JWT
+├── alembic/                 # Migrações do banco
+│   ├── versions/            # Arquivos de migração
+│   ├── env.py               # Configuração do Alembic
+│   └── script.py.mako       # Template de migração
+├── data/                    # Banco SQLite
+├── Dockerfile              # Container da aplicação
+├── docker-compose.yml      # Orquestração
+├── alembic.ini             # Configuração do Alembic
+├── pytest.ini             # Configuração do pytest
+└── requirements.txt        # Dependências Python
+```
 
 #### Dúvidas?