Django

https://www.djangoproject.com/

Recipe REST API - Udemy course

https://www.udemy.com/course/django-python-advanced/

API Features:

• 19 API Endpoints

Managing users, recipes, tags, ingredients

• User Authentication
• Browseable Admin Interface (Django Admin)
• Browsable API (Swagger)

Techologies used in this course:

• Django allows handle: URL Mappings / Object Relational Mapper / Admin site
• Django REST Framework: Django add-on / Build REST APIs
• PostgresSQL
• Docker
• Git
• Swagger: Documentation / Browsable API (testing)

Structure of the project:

• app/ : Main app - Django project
• app/core/ : Hangle any code shared between multiple apps. Such as the DB definition using the Django modules
• app/user/ : User related code. Such as User registration & auth tokens
• app/recipe/ : Recipe related code. Such as handling updating ingredients - Creating/Deleting/Udating recipes

Unit Tests and Test-driven development (TDD)

See explanation at https://www.udemy.com/course/django-python-advanced/learn/lecture/32238668#notes

• Unit Tests: Code which test code:

It's usually done this way:

• You Set up some conditions; such as inputs to a function
• Then you run a piece of code
• Checks outputs of that code using "assertions"

Test-driven development (TDD)

... pegar la imagen de la presentacion que tomé del curso ...

Docker

Some benefits of using Docker Docker#Why use Docker

Drawbacks of using Docker in this project: (Not sure if these limitations are still in place)

• VSCode will be unable to access interpreter
• More Difficult to use integrated features

How will be used Docker in this project:

• Define a Dockerfile: Contains all the OS level dependencies that our project needs.
• Create a Docker Compose configuration: Tells Docker how to run the images that are created from our Docker file configuration.
• Run all commands via Docker Compose. For example:

docker-compose run --rm app sh -c "python manage.py collectstatic"

• docker-compose runs a Docker Compose command
• run will start a specific container defined in config
• --rm removes the container
• app is the name of the service
• sh -c pass in a shell command

• Docker on GitHub Actions:

• Docker Hub is where we can pull shared public images to reuse them for your project. For example there an image for Python, PostgreSQL, etc. Docker Hub has introduced rate limits.

• Because of the rate limits, we have to Authenticate with Docker Hub: Create an account / Setup credentials / Login before running job.
• https://hub.docker.com/

Setting the development environment

• requirements.txt

Django>=3.2.4,<3.3
djangorestframework>=3.12.4,<3.13

• Dockerfile

---
name: Checks

on: [push]

jobs:
  test-lint:
    name: Test and Lint
    runs-on: ubuntu-20.04
    steps:
      - name: Login to Docker Hub
        uses: docker/login-action@v1
        with:
          username: ${{ secrets.DOCKERHUB_USER }}
          password: ${{ secrets.DOCKERHUB_TOKEN }}
      - name: Checkout
        uses: actions/checkout@v2
      - name: Test
        run: docker-compose run --rm app sh -c "python manage.py test"
      - name: Lint
        run: docker-compose run --rm app sh -c "flake8"

• .dockerignore

# Git
.git
.gitignore

# Docker
.docker

# Python
app/__pycache__/
app/*/__pycache__/
app/*/*/__pycache__/
app/*/*/*/__pycache__/
.env/
.venv/
venv/

• Then we create the app directory insde our project directory

mkdir app

• Then we run:

docker build .

• docker-compose.yml

version: "3.9"

services:
  app:
    build:
      context: .
      args:
        - DEV=true
    ports:
      - "8000:8000"
    volumes:
      - ./app:/app
    command: >
      sh -c "python manage.py runserver 0.0.0.0:8000"

• Then we run in our project directory:

docker-compose build

• ...:

docker-compose run --rm app sh -c "flake8"

docker-compose run --rm app sh -c "django-admin startproject app ."

docker-compose up