Forem: Ulrich (Houngbe)

Tests unitaires : bonnes pratiques

Ulrich (Houngbe) — Sat, 23 May 2026 09:44:44 +0000

Tests Unitaires : Bonnes Pratiques pour un Code Fiable

Les tests unitaires sont la fondation d'une base de code robuste et maintenable. Ce guide vous accompagne dans l'écriture de tests efficaces qui apportent une réelle valeur.

Pourquoi les Tests Unitaires ?

Bénéfices Concrets

Détection précoce des bugs avant la production
Documentation vivante du comportement attendu
Refactoring sécurisé avec confiance
Réduction des coûts de maintenance
Amélioration du design du code

Coût vs Valeur

// Sans tests : coût d'un bug en production
const productionBugCost = developmentTime * 10 + customerImpact + reputationDamage;

// Avec tests : coût préventif
const testingCost = developmentTime * 1.2 + testMaintenance;

// ROI = (productionBugCost - testingCost) / testingCost

Anatomie d'un Bon Test

Pattern AAA (Arrange, Act, Assert)

// ✅ Test bien structuré
describe('UserService', () => {
  describe('createUser', () => {
    it('should create a user with valid data', async () => {
      // Arrange - Préparer les données et mocks
      const userData = {
        name: 'John Doe',
        email: 'john@example.com',
        age: 25
      };
      const mockRepository = {
        save: jest.fn().mockResolvedValue({ id: 1, ...userData }),
        findByEmail: jest.fn().mockResolvedValue(null)
      };
      const userService = new UserService(mockRepository);

      // Act - Exécuter l'action à tester
      const result = await userService.createUser(userData);

      // Assert - Vérifier le résultat
      expect(result).toEqual({
        id: 1,
        name: 'John Doe',
        email: 'john@example.com',
        age: 25
      });
      expect(mockRepository.save).toHaveBeenCalledWith(userData);
      expect(mockRepository.findByEmail).toHaveBeenCalledWith('john@example.com');
    });
  });
});

Tests Paramétrés avec describe.each

// ✅ Tests paramétrés pour plusieurs scénarios
describe.each([
  { input: '', expected: false, description: 'empty string' },
  { input: 'invalid-email', expected: false, description: 'missing @' },
  { input: 'test@', expected: false, description: 'missing domain' },
  { input: 'test@example.com', expected: true, description: 'valid email' },
  { input: 'user+tag@domain.co.uk', expected: true, description: 'complex valid email' }
])('Email validation', ({ input, expected, description }) => {
  it(`should return ${expected} for ${description}`, () => {
    const result = validateEmail(input);
    expect(result).toBe(expected);
  });
});

Techniques de Mocking Avancées

1. Dependency Injection et Mocking

// Service à tester
class OrderService {
  constructor(paymentService, emailService, inventoryService) {
    this.paymentService = paymentService;
    this.emailService = emailService;
    this.inventoryService = inventoryService;
  }

  async processOrder(order) {
    // Vérifier le stock
    const hasStock = await this.inventoryService.checkStock(order.productId, order.quantity);
    if (!hasStock) {
      throw new Error('Insufficient stock');
    }

    // Traiter le paiement
    const payment = await this.paymentService.processPayment({
      amount: order.total,
      card: order.card
    });

    // Mettre à jour le stock
    await this.inventoryService.reduceStock(order.productId, order.quantity);

    // Envoyer confirmation
    await this.emailService.sendConfirmation(order.customerEmail, {
      orderId: payment.transactionId,
      amount: order.total
    });

    return {
      orderId: payment.transactionId,
      status: 'confirmed',
      amount: order.total
    };
  }
}

// Tests avec mocks complets
describe('OrderService', () => {
  let orderService;
  let mockPaymentService;
  let mockEmailService;
  let mockInventoryService;

  beforeEach(() => {
    mockPaymentService = {
      processPayment: jest.fn()
    };
    mockEmailService = {
      sendConfirmation: jest.fn()
    };
    mockInventoryService = {
      checkStock: jest.fn(),
      reduceStock: jest.fn()
    };

    orderService = new OrderService(
      mockPaymentService,
      mockEmailService,
      mockInventoryService
    );
  });

  describe('processOrder', () => {
    const validOrder = {
      productId: 'prod-123',
      quantity: 2,
      total: 99.99,
      card: '4111111111111111',
      customerEmail: 'customer@example.com'
    };

    it('should process order successfully with valid data', async () => {
      // Arrange
      mockInventoryService.checkStock.mockResolvedValue(true);
      mockPaymentService.processPayment.mockResolvedValue({
        transactionId: 'tx-456',
        status: 'success'
      });
      mockInventoryService.reduceStock.mockResolvedValue(true);
      mockEmailService.sendConfirmation.mockResolvedValue(true);

      // Act
      const result = await orderService.processOrder(validOrder);

      // Assert
      expect(result).toEqual({
        orderId: 'tx-456',
        status: 'confirmed',
        amount: 99.99
      });

      // Vérifier les appels dans l'ordre
      expect(mockInventoryService.checkStock).toHaveBeenCalledWith('prod-123', 2);
      expect(mockPaymentService.processPayment).toHaveBeenCalledWith({
        amount: 99.99,
        card: '4111111111111111'
      });
      expect(mockInventoryService.reduceStock).toHaveBeenCalledWith('prod-123', 2);
      expect(mockEmailService.sendConfirmation).toHaveBeenCalledWith(
        'customer@example.com',
        { orderId: 'tx-456', amount: 99.99 }
      );
    });

    it('should throw error when insufficient stock', async () => {
      // Arrange
      mockInventoryService.checkStock.mockResolvedValue(false);

      // Act & Assert
      await expect(orderService.processOrder(validOrder))
        .rejects.toThrow('Insufficient stock');

      // Vérifier que les autres services ne sont pas appelés
      expect(mockPaymentService.processPayment).not.toHaveBeenCalled();
      expect(mockInventoryService.reduceStock).not.toHaveBeenCalled();
      expect(mockEmailService.sendConfirmation).not.toHaveBeenCalled();
    });
  });
});

2. Mocking Avancé avec Jest

// Mock de modules externes
jest.mock('axios');
const mockedAxios = axios as jest.Mocked<typeof axios>;

// Mock de fonctions avec implémentation
const mockFunction = jest.fn()
  .mockReturnValue('default')
  .mockReturnValueOnce('first call')
  .mockResolvedValue('async result');

// Mock d'une classe
jest.mock('../services/DatabaseService');
const MockedDatabase = DatabaseService as jest.MockedClass<typeof DatabaseService>;

beforeEach(() => {
  MockedDatabase.mockClear();
  MockedDatabase.prototype.find.mockClear();
});

// Spy sur des méthodes existantes
const consoleSpy = jest.spyOn(console, 'log').mockImplementation(() => {});

afterAll(() => {
  consoleSpy.mockRestore();
});

Testing de Code Asynchrone

1. Promises et Async/Await

// ✅ Tests async propres
describe('AsyncUserService', () => {
  it('should handle async user creation', async () => {
    const userData = { name: 'John', email: 'john@test.com' };

    const result = await userService.createUser(userData);

    expect(result).toBeDefined();
    expect(result.id).toBeTruthy();
  });

  it('should reject invalid user data', async () => {
    const invalidData = { name: '', email: 'invalid' };

    await expect(userService.createUser(invalidData))
      .rejects.toThrow('Invalid user data');
  });

  it('should handle database errors gracefully', async () => {
    mockRepository.save.mockRejectedValue(new Error('Database connection failed'));

    await expect(userService.createUser(userData))
      .rejects.toThrow('Database connection failed');
  });
});

2. Testing des Timers

// Fonctions utilisant setTimeout
class NotificationService {
  scheduleReminder(callback, delay) {
    setTimeout(() => {
      callback('Reminder: Check your tasks!');
    }, delay);
  }

  scheduleRecurring(callback, interval) {
    return setInterval(() => {
      callback('Recurring notification');
    }, interval);
  }
}

// Tests avec fake timers
describe('NotificationService', () => {
  let notificationService;

  beforeEach(() => {
    jest.useFakeTimers();
    notificationService = new NotificationService();
  });

  afterEach(() => {
    jest.useRealTimers();
  });

  it('should execute callback after specified delay', () => {
    const mockCallback = jest.fn();

    notificationService.scheduleReminder(mockCallback, 5000);

    // Rien ne devrait être appelé immédiatement
    expect(mockCallback).not.toHaveBeenCalled();

    // Avancer le temps de 5 secondes
    jest.advanceTimersByTime(5000);

    expect(mockCallback).toHaveBeenCalledWith('Reminder: Check your tasks!');
  });

  it('should execute recurring callback multiple times', () => {
    const mockCallback = jest.fn();

    const intervalId = notificationService.scheduleRecurring(mockCallback, 1000);

    // Avancer le temps et vérifier les appels
    jest.advanceTimersByTime(3000);

    expect(mockCallback).toHaveBeenCalledTimes(3);
    expect(mockCallback).toHaveBeenCalledWith('Recurring notification');

    clearInterval(intervalId);
  });
});

Tests d'Intégration et de Bout en Bout

1. Tests d'Intégration de Base de Données

// Configuration de test avec base de données de test
const { Pool } = require('pg');
const fs = require('fs');

describe('UserRepository Integration Tests', () => {
  let pool;
  let userRepository;

  beforeAll(async () => {
    // Configuration de la DB de test
    pool = new Pool({
      connectionString: process.env.TEST_DATABASE_URL
    });

    // Setup du schéma
    const schema = fs.readFileSync('./migrations/001_create_users.sql', 'utf8');
    await pool.query(schema);

    userRepository = new UserRepository(pool);
  });

  beforeEach(async () => {
    // Nettoyer la DB avant chaque test
    await pool.query('TRUNCATE TABLE users RESTART IDENTITY CASCADE');
  });

  afterAll(async () => {
    await pool.end();
  });

  it('should create and retrieve a user', async () => {
    // Arrange
    const userData = {
      name: 'Integration Test User',
      email: 'integration@test.com'
    };

    // Act
    const createdUser = await userRepository.create(userData);
    const retrievedUser = await userRepository.findById(createdUser.id);

    // Assert
    expect(retrievedUser).toEqual(expect.objectContaining(userData));
    expect(retrievedUser.id).toBeTruthy();
    expect(retrievedUser.createdAt).toBeInstanceOf(Date);
  });
});

2. Tests API avec Supertest

const request = require('supertest');
const app = require('../app');

describe('API Endpoints', () => {
  describe('POST /api/users', () => {
    it('should create a new user', async () => {
      const userData = {
        name: 'Test User',
        email: 'test@example.com'
      };

      const response = await request(app)
        .post('/api/users')
        .send(userData)
        .expect(201);

      expect(response.body).toEqual({
        id: expect.any(Number),
        name: 'Test User',
        email: 'test@example.com',
        createdAt: expect.any(String)
      });
    });

    it('should validate required fields', async () => {
      const response = await request(app)
        .post('/api/users')
        .send({})
        .expect(400);

      expect(response.body.error).toContain('validation failed');
    });

    it('should handle duplicate email', async () => {
      const userData = {
        name: 'Test User',
        email: 'duplicate@test.com'
      };

      // Premier utilisateur
      await request(app)
        .post('/api/users')
        .send(userData)
        .expect(201);

      // Tentative de doublon
      const response = await request(app)
        .post('/api/users')
        .send(userData)
        .expect(409);

      expect(response.body.error).toContain('already exists');
    });
  });
});

Test-Driven Development (TDD)

Cycle Red-Green-Refactor

// 1. RED - Écrire un test qui échoue
describe('Calculator', () => {
  it('should add two numbers correctly', () => {
    const calculator = new Calculator();
    const result = calculator.add(2, 3);
    expect(result).toBe(5);
  });
});

// 2. GREEN - Écrire le minimum de code pour faire passer le test
class Calculator {
  add(a, b) {
    return a + b;
  }
}

// 3. REFACTOR - Améliorer le code tout en gardant les tests verts
class Calculator {
  add(a, b) {
    this.validateNumbers(a, b);
    return a + b;
  }

  validateNumbers(...numbers) {
    numbers.forEach(num => {
      if (typeof num !== 'number' || isNaN(num)) {
        throw new Error('Invalid number provided');
      }
    });
  }
}

// Ajouter plus de tests
describe('Calculator', () => {
  let calculator;

  beforeEach(() => {
    calculator = new Calculator();
  });

  describe('add', () => {
    it('should add two positive numbers', () => {
      expect(calculator.add(2, 3)).toBe(5);
    });

    it('should add negative numbers', () => {
      expect(calculator.add(-2, -3)).toBe(-5);
    });

    it('should handle decimal numbers', () => {
      expect(calculator.add(0.1, 0.2)).toBeCloseTo(0.3);
    });

    it('should throw error for invalid input', () => {
      expect(() => calculator.add('2', 3)).toThrow('Invalid number provided');
      expect(() => calculator.add(2, null)).toThrow('Invalid number provided');
    });
  });
});

Coverage et Métriques

1. Configuration de Coverage avec Jest

// jest.config.js
module.exports = {
  collectCoverage: true,
  coverageDirectory: 'coverage',
  coverageReporters: ['text', 'lcov', 'html'],
  collectCoverageFrom: [
    'src/**/*.js',
    '!src/**/*.test.js',
    '!src/config/**',
    '!src/migrations/**'
  ],
  coverageThreshold: {
    global: {
      branches: 80,
      functions: 80,
      lines: 80,
      statements: 80
    },
    './src/services/': {
      branches: 90,
      functions: 90,
      lines: 90,
      statements: 90
    }
  }
};

2. Analyse de Coverage

# Générer un rapport détaillé
npm test -- --coverage --watchAll=false

# Ouvrir le rapport HTML
open coverage/lcov-report/index.html

# Coverage par fichier
Jest Coverage Report
------------------------
File      | % Stmts | % Branch | % Funcs | % Lines | Uncovered Lines
----------|---------|----------|---------|---------|----------------
All files |   85.5  |   78.2   |   89.1  |   85.3  |
services/ |   92.3  |   85.7   |   94.4  |   92.1  |
utils/    |   76.8  |   68.9   |   81.2  |   76.5  | 45-52, 78-82

Bonnes Pratiques

1. Nommage et Organisation

// ✅ Nommage descriptif
describe('UserService', () => {
  describe('when creating a user', () => {
    describe('with valid data', () => {
      it('should return the created user with an ID', () => {});
      it('should save the user to the database', () => {});
    });

    describe('with invalid email', () => {
      it('should throw ValidationError', () => {});
      it('should not save anything to database', () => {});
    });
  });
});

// ✅ Tests isolés et déterministes
beforeEach(() => {
  // Reset tous les mocks
  jest.clearAllMocks();

  // État initial propre
  database.clear();
  cache.flush();
});

2. Tests Lisibles et Maintenables

// ✅ Factory pattern pour les données de test
class UserFactory {
  static create(overrides = {}) {
    return {
      name: 'John Doe',
      email: 'john@example.com',
      age: 25,
      isActive: true,
      ...overrides
    };
  }

  static createMany(count, overrides = {}) {
    return Array.from({ length: count }, (_, i) => 
      this.create({ ...overrides, email: `user${i}@test.com` })
    );
  }
}

// Usage
it('should handle multiple users', async () => {
  const users = UserFactory.createMany(3, { isActive: true });
  await userService.createBatch(users);

  const activeUsers = await userService.findActive();
  expect(activeUsers).toHaveLength(3);
});

3. Éviter les Anti-Patterns

// ❌ Test trop complexe
it('should handle complex user workflow', async () => {
  // 50 lignes de setup...
  // Test de 10 choses différentes...
});

// ✅ Tests simples et focalisés
it('should create user', async () => {
  const user = await userService.create(validUserData);
  expect(user.id).toBeTruthy();
});

it('should validate user email', () => {
  expect(() => userService.validateEmail('invalid'))
    .toThrow('Invalid email');
});

// ❌ Tests fragiles liés à l'implémentation
it('should call database twice', () => {
  userService.createUser(userData);
  expect(mockDb.query).toHaveBeenCalledTimes(2);
});

// ✅ Tests focalisés sur le comportement
it('should create user and return result', async () => {
  const result = await userService.createUser(userData);
  expect(result).toEqual(expectedUser);
});

Conclusion

Les tests unitaires efficaces reposent sur :

Tests simples et focalisés sur un comportement spécifique
Isolation complète grâce aux mocks appropriés
Couverture pertinente plutôt que maximale
Maintenance continue avec refactoring régulier
TDD pour guider le design du code

Un investissement initial dans une stratégie de test solide se traduit par :

Réduction significative des bugs en production
Confiance pour refactorer et faire évoluer le code
Documentation vivante du comportement attendu
Feedback rapide pendant le développement

La clé est de voir les tests comme un investissement, pas comme un coût.

REST vs GraphQL

Ulrich (Houngbe) — Fri, 22 May 2026 10:43:26 +0000

REST vs GraphQL : Guide de Choix pour votre API

Le débat entre REST et GraphQL anime la communauté depuis l'émergence de GraphQL en 2015. Ce guide vous aide à choisir la meilleure approche selon votre contexte.

Vue d'ensemble des Paradigmes

REST (Representational State Transfer)

Architecture : Basée sur les ressources et les verbes HTTP
Maturité : Standard établi depuis 2000
Philosophie : "Une URL = Une ressource"
Communication : Stateless, cacheable, interface uniforme

GraphQL

Architecture : Basée sur un schéma et un langage de requête
Origine : Développé par Facebook en 2012, open source en 2015
Philosophie : "Une seule URL, plusieurs possibilités"
Communication : Requêtes flexibles, typage fort

Comparaison Technique Détaillée

1. Structure des Requêtes

REST - Multiple Endpoints

// Récupérer un utilisateur
GET /api/users/123
{
  "id": 123,
  "name": "John Doe",
  "email": "john@example.com"
}

// Récupérer ses posts
GET /api/users/123/posts
[
  {
    "id": 456,
    "title": "Mon premier post",
    "content": "Contenu du post..."
  }
]

// Récupérer les commentaires d'un post
GET /api/posts/456/comments

GraphQL - Single Endpoint

# Une seule requête pour tout récupérer
query {
  user(id: 123) {
    name
    email
    posts {
      title
      content
      comments {
        author
        text
      }
    }
  }
}

2. Implémentation Backend

API REST avec Express.js

const express = require('express');
const app = express();

// Routes séparées pour chaque ressource
app.get('/api/users/:id', async (req, res) => {
  const user = await User.findById(req.params.id);
  res.json(user);
});

app.get('/api/users/:id/posts', async (req, res) => {
  const posts = await Post.findByUserId(req.params.id);
  res.json(posts);
});

app.post('/api/posts', async (req, res) => {
  const post = await Post.create(req.body);
  res.status(201).json(post);
});

app.put('/api/posts/:id', async (req, res) => {
  const post = await Post.findByIdAndUpdate(req.params.id, req.body);
  res.json(post);
});

app.delete('/api/posts/:id', async (req, res) => {
  await Post.findByIdAndDelete(req.params.id);
  res.status(204).send();
});

API GraphQL avec Apollo Server

const { ApolloServer } = require('@apollo/server');
const { startStandaloneServer } = require('@apollo/server/standalone');

// Schéma GraphQL
const typeDefs = `
  type User {
    id: ID!
    name: String!
    email: String!
    posts: [Post!]!
  }

  type Post {
    id: ID!
    title: String!
    content: String!
    author: User!
    comments: [Comment!]!
  }

  type Comment {
    id: ID!
    text: String!
    author: User!
  }

  type Query {
    user(id: ID!): User
    users: [User!]!
    post(id: ID!): Post
    posts: [Post!]!
  }

  type Mutation {
    createPost(title: String!, content: String!, authorId: ID!): Post!
    updatePost(id: ID!, title: String, content: String): Post!
    deletePost(id: ID!): Boolean!
  }
`;

// Resolvers
const resolvers = {
  Query: {
    user: async (_, { id }) => await User.findById(id),
    users: async () => await User.findAll(),
    post: async (_, { id }) => await Post.findById(id),
    posts: async () => await Post.findAll(),
  },

  Mutation: {
    createPost: async (_, { title, content, authorId }) => {
      return await Post.create({ title, content, authorId });
    },
    updatePost: async (_, { id, title, content }) => {
      return await Post.findByIdAndUpdate(id, { title, content });
    },
    deletePost: async (_, { id }) => {
      await Post.findByIdAndDelete(id);
      return true;
    },
  },

  User: {
    posts: async (user) => await Post.findByUserId(user.id),
  },

  Post: {
    author: async (post) => await User.findById(post.authorId),
    comments: async (post) => await Comment.findByPostId(post.id),
  },

  Comment: {
    author: async (comment) => await User.findById(comment.authorId),
  },
};

const server = new ApolloServer({
  typeDefs,
  resolvers,
});

startStandaloneServer(server, { listen: { port: 4000 } });

Avantages et Inconvénients

REST

✅ Avantages

Simplicité : Facile à comprendre et implémenter
Cache HTTP : Support natif avec les headers HTTP
Maturité : Écosystème riche et bien établi
Debugging : Outils familiers (curl, Postman)
Stateless : Scalabilité et fiabilité

// Cache HTTP avec REST
app.get('/api/users/:id', (req, res) => {
  res.set('Cache-Control', 'public, max-age=300'); // 5 minutes
  res.json(user);
});

// Headers utiles
res.set({
  'ETag': '"123456"',
  'Last-Modified': user.updatedAt,
  'X-RateLimit-Remaining': '99'
});

❌ Inconvénients

Over/Under-fetching : Récupération de données inutiles ou insuffisantes
Multiples requêtes : Problème N+1 fréquent
Versionning : Gestion complexe des versions

// Problème d'over-fetching
GET /api/users/123
// Retourne TOUS les champs même si on n'a besoin que du nom

// Under-fetching - plusieurs requêtes nécessaires
GET /api/users/123        // Infos utilisateur
GET /api/users/123/posts  // Ses posts
GET /api/posts/456/stats  // Stats du premier post

GraphQL

✅ Avantages

Flexibilité : Récupération précise des données
Une seule requête : Évite le problème N+1
Typage fort : Validation automatique
Introspection : Documentation auto-générée
Real-time : Subscriptions intégrées

# Récupération précise des données
query GetUserDashboard {
  user(id: 123) {
    name
    avatar
    posts(limit: 5) {
      title
      publishedAt
      viewCount
    }
    notifications(unreadOnly: true) {
      type
      message
    }
  }
}

# Mutations avec validation
mutation CreatePost($input: CreatePostInput!) {
  createPost(input: $input) {
    id
    title
    slug
    publishedAt
  }
}

# Subscriptions temps réel
subscription {
  postAdded {
    id
    title
    author {
      name
    }
  }
}

❌ Inconvénients

Complexité : Courbe d'apprentissage plus raide
Cache : Mise en cache plus complexe
Sécurité : Risques de requêtes coûteuses
Performance : Parsing et validation des requêtes

Patterns et Optimisations

1. REST - Optimisations

Pagination et Filtrage

// Pagination avec curseur
GET /api/posts?cursor=abc123&limit=20&sort=createdAt:desc

// Filtrage et champs spécifiques
GET /api/users?filter=active:true&fields=name,email&include=profile

// Response
{
  "data": [
    { "name": "John", "email": "john@example.com", "profile": {...} }
  ],
  "pagination": {
    "nextCursor": "xyz789",
    "hasMore": true,
    "total": 150
  }
}

HATEOAS (Hypermedia)

{
  "id": 123,
  "title": "Mon Post",
  "status": "published",
  "_links": {
    "self": { "href": "/api/posts/123" },
    "author": { "href": "/api/users/456" },
    "comments": { "href": "/api/posts/123/comments" },
    "edit": { "href": "/api/posts/123", "method": "PUT" },
    "delete": { "href": "/api/posts/123", "method": "DELETE" }
  }
}

2. GraphQL - Optimisations

DataLoader pour éviter N+1

const DataLoader = require('dataloader');

// Batch loading des utilisateurs
const userLoader = new DataLoader(async (userIds) => {
  const users = await User.findByIds(userIds);
  return userIds.map(id => users.find(user => user.id === id));
});

const resolvers = {
  Post: {
    author: async (post) => userLoader.load(post.authorId),
  },
  Comment: {
    author: async (comment) => userLoader.load(comment.authorId),
  },
};

Limitation de Profondeur

const depthLimit = require('graphql-depth-limit');

const server = new ApolloServer({
  typeDefs,
  resolvers,
  validationRules: [depthLimit(7)], // Max 7 niveaux de profondeur
});

Cache avec Redis

const Redis = require('ioredis');
const redis = new Redis();

const resolvers = {
  Query: {
    user: async (_, { id }) => {
      const cached = await redis.get(`user:${id}`);
      if (cached) return JSON.parse(cached);

      const user = await User.findById(id);
      await redis.setex(`user:${id}`, 300, JSON.stringify(user));
      return user;
    },
  },
};

Gestion d'État Côté Client

1. REST avec React Query

import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';

function UserProfile({ userId }) {
  const queryClient = useQueryClient();

  const { data: user, isLoading } = useQuery({
    queryKey: ['user', userId],
    queryFn: () => fetch(`/api/users/${userId}`).then(r => r.json()),
    staleTime: 5 * 60 * 1000, // 5 minutes
  });

  const { data: posts } = useQuery({
    queryKey: ['posts', userId],
    queryFn: () => fetch(`/api/users/${userId}/posts`).then(r => r.json()),
    enabled: !!userId,
  });

  const updateUser = useMutation({
    mutationFn: (userData) => 
      fetch(`/api/users/${userId}`, {
        method: 'PUT',
        body: JSON.stringify(userData),
      }),
    onSuccess: () => {
      queryClient.invalidateQueries(['user', userId]);
    },
  });

  if (isLoading) return <div>Chargement...</div>;

  return (
    <div>
      <h1>{user.name}</h1>
      <p>{user.email}</p>
      <div>
        {posts?.map(post => (
          <article key={post.id}>{post.title}</article>
        ))}
      </div>
    </div>
  );
}

2. GraphQL avec Apollo Client

import { useQuery, useMutation, gql } from '@apollo/client';

const GET_USER_WITH_POSTS = gql`
  query GetUserWithPosts($userId: ID!) {
    user(id: $userId) {
      name
      email
      posts {
        id
        title
        content
      }
    }
  }
`;

const UPDATE_USER = gql`
  mutation UpdateUser($id: ID!, $input: UpdateUserInput!) {
    updateUser(id: $id, input: $input) {
      name
      email
    }
  }
`;

function UserProfile({ userId }) {
  const { data, loading } = useQuery(GET_USER_WITH_POSTS, {
    variables: { userId },
    pollInterval: 30000, // Refresh toutes les 30s
  });

  const [updateUser] = useMutation(UPDATE_USER, {
    update(cache, { data: { updateUser } }) {
      cache.modify({
        id: cache.identify({ __typename: 'User', id: userId }),
        fields: {
          name: () => updateUser.name,
          email: () => updateUser.email,
        },
      });
    },
  });

  if (loading) return <div>Chargement...</div>;

  return (
    <div>
      <h1>{data.user.name}</h1>
      <p>{data.user.email}</p>
      <div>
        {data.user.posts.map(post => (
          <article key={post.id}>{post.title}</article>
        ))}
      </div>
    </div>
  );
}

Sécurité et Performance

1. Sécurité REST

const rateLimit = require('express-rate-limit');
const helmet = require('helmet');

// Rate limiting
const limiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15 minutes
  max: 100, // 100 requêtes par fenêtre
});

app.use(limiter);
app.use(helmet());

// Validation avec Joi
const Joi = require('joi');

const userSchema = Joi.object({
  name: Joi.string().min(2).max(50).required(),
  email: Joi.string().email().required(),
});

app.post('/api/users', (req, res) => {
  const { error, value } = userSchema.validate(req.body);
  if (error) return res.status(400).json({ error: error.details });

  // Traiter la création...
});

2. Sécurité GraphQL

const { shield, rule, and, or } = require('graphql-shield');
const { createRateLimiterDirective } = require('graphql-rate-limit');

const isAuthenticated = rule({ cache: 'contextual' })(
  async (parent, args, context) => {
    return context.user !== null;
  }
);

const isOwner = rule({ cache: 'strict' })(
  async (parent, { id }, context) => {
    const post = await Post.findById(id);
    return post.authorId === context.user.id;
  }
);

// Shield de permissions
const permissions = shield({
  Query: {
    user: isAuthenticated,
    posts: isAuthenticated,
  },
  Mutation: {
    createPost: isAuthenticated,
    updatePost: and(isAuthenticated, isOwner),
    deletePost: and(isAuthenticated, isOwner),
  },
});

// Rate limiting par directive
const rateLimiterDirective = createRateLimiterDirective({
  identifyContext: (context) => context.user?.id || context.ip,
});

const server = new ApolloServer({
  typeDefs: `
    ${rateLimiterDirective.typeDefs}

    type Query {
      posts: [Post!]! @rateLimit(max: 100, window: "15m")
    }
  `,
  schemaDirectives: {
    rateLimit: rateLimiterDirective.directive,
  },
  schema: applyMiddleware(schema, permissions),
});

Guide de Choix

Choisir REST si :

Équipe débutante en APIs
Cache HTTP crucial pour les performances
Architecture microservices avec services spécialisés
APIs publiques nécessitant une large compatibilité
Opérations CRUD simples prédominantes

Choisir GraphQL si :

Applications mobiles avec contraintes de bande passante
Interfaces complexes avec besoins de données variés
Équipe expérimentée prête pour la complexité
Développement rapide d'interfaces
Temps réel important (subscriptions)

Conclusion

Le choix entre REST et GraphQL dépend principalement de votre contexte :

REST reste le choix de référence pour sa simplicité, sa maturité et son excellente compatibilité avec l'infrastructure web existante.

GraphQL excelle dans les contextes où la flexibilité des requêtes et l'optimisation du trafic réseau sont prioritaires.

Dans de nombreux cas, une approche hybride peut être pertinente : REST pour les APIs publiques et les opérations simples, GraphQL pour les interfaces complexes et les applications mobiles.

L'important est de choisir en fonction de vos contraintes réelles, pas des tendances du moment.

Docker pour les devs backend

Ulrich (Houngbe) — Thu, 21 May 2026 11:00:28 +0000

Docker pour les Développeurs Backend : Guide Pratique

Docker révolutionne le développement backend en résolvant le fameux "ça marche sur ma machine". Ce guide vous accompagne dans la maîtrise de Docker pour vos applications backend.

Pourquoi Docker pour le Backend ?

Problèmes Résolus

Environnements cohérents entre développement, test et production
Isolation des dépendances et des versions
Déploiements reproductibles et scalables
Gestion simplifiée des services (bases de données, cache, etc.)

Concepts Fondamentaux

1. Images vs Conteneurs

# Une image est un template immutable
docker build -t myapp:v1.0 .

# Un conteneur est une instance en cours d'exécution
docker run -d --name myapp-instance myapp:v1.0

# Lister les images et conteneurs
docker images
docker ps -a

2. Architecture Docker

Application
    ↓
Docker Daemon
    ↓
Host OS Kernel

Dockerfile pour Applications Backend

1. Application Node.js/Express

# Dockerfile
FROM node:18-alpine AS base

# Installer des dépendances système si nécessaire
RUN apk add --no-cache python3 make g++

WORKDIR /app

# Optimisation du cache Docker
COPY package*.json ./
RUN npm ci --only=production && npm cache clean --force

# Multi-stage build pour optimiser la taille
FROM node:18-alpine AS development
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
EXPOSE 3000
CMD ["npm", "run", "dev"]

# Image de production
FROM base AS production
COPY . .
RUN addgroup -g 1001 -S nodejs
RUN adduser -S nodejs -u 1001
USER nodejs
EXPOSE 3000
CMD ["npm", "start"]

2. Application Python/FastAPI

# Dockerfile
FROM python:3.11-slim AS base

# Variables d'environnement
ENV PYTHONUNBUFFERED=1 \
    PYTHONDONTWRITEBYTECODE=1 \
    PIP_NO_CACHE_DIR=1 \
    PIP_DISABLE_PIP_VERSION_CHECK=1

# Installer les dépendances système
RUN apt-get update && apt-get install -y \
    build-essential \
    curl \
    && rm -rf /var/lib/apt/lists/*

WORKDIR /app

# Installer Poetry pour la gestion des dépendances
RUN pip install poetry
COPY pyproject.toml poetry.lock ./
RUN poetry config virtualenvs.create false \
    && poetry install --no-dev --no-interaction --no-ansi

# Image de développement
FROM base AS development
RUN poetry install --no-interaction --no-ansi
COPY . .
EXPOSE 8000
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000", "--reload"]

# Image de production
FROM base AS production
COPY . .
RUN adduser --disabled-password --gecos '' appuser
USER appuser
EXPOSE 8000
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

3. Application Java/Spring Boot

# Dockerfile
FROM openjdk:17-jdk-slim AS build

WORKDIR /app
COPY gradlew .
COPY gradle gradle
COPY build.gradle .
COPY settings.gradle .

# Cache des dépendances
RUN ./gradlew dependencies --no-daemon

COPY src src
RUN ./gradlew bootJar --no-daemon

# Image de production
FROM openjdk:17-jre-slim AS production

RUN addgroup --system spring && adduser --system spring --ingroup spring
USER spring:spring

COPY --from=build /app/build/libs/*.jar app.jar

EXPOSE 8080
ENTRYPOINT ["java", "-jar", "/app.jar"]

Docker Compose pour le Stack Complet

1. Stack Node.js avec PostgreSQL et Redis

# docker-compose.yml
version: '3.8'

services:
  app:
    build:
      context: .
      target: development
    ports:
      - "3000:3000"
    environment:
      - NODE_ENV=development
      - DB_HOST=postgres
      - DB_PORT=5432
      - DB_NAME=myapp
      - DB_USER=postgres
      - DB_PASSWORD=password
      - REDIS_HOST=redis
      - REDIS_PORT=6379
    volumes:
      - .:/app
      - /app/node_modules
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_started
    networks:
      - app-network

  postgres:
    image: postgres:15-alpine
    environment:
      POSTGRES_DB: myapp
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: password
    ports:
      - "5432:5432"
    volumes:
      - postgres_data:/var/lib/postgresql/data
      - ./init.sql:/docker-entrypoint-initdb.d/init.sql
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres"]
      interval: 10s
      timeout: 5s
      retries: 5
    networks:
      - app-network

  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"
    volumes:
      - redis_data:/data
    command: redis-server --appendonly yes
    networks:
      - app-network

  nginx:
    image: nginx:alpine
    ports:
      - "80:80"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
    depends_on:
      - app
    networks:
      - app-network

volumes:
  postgres_data:
  redis_data:

networks:
  app-network:
    driver: bridge

2. Configuration Nginx

# nginx.conf
events {
    worker_connections 1024;
}

http {
    upstream app_servers {
        server app:3000;
    }

    server {
        listen 80;

        location / {
            proxy_pass http://app_servers;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header X-Forwarded-Proto $scheme;
        }

        location /health {
            access_log off;
            return 200 "healthy\n";
            add_header Content-Type text/plain;
        }
    }
}

Optimisation et Bonnes Pratiques

1. Multi-stage Build Optimisé

# Dockerfile optimisé
FROM node:18-alpine AS dependencies
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production

FROM node:18-alpine AS build
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

FROM node:18-alpine AS runtime
RUN addgroup -g 1001 -S nodejs \
    && adduser -S nodejs -u 1001

WORKDIR /app
USER nodejs

# Copier seulement ce qui est nécessaire
COPY --from=dependencies --chown=nodejs:nodejs /app/node_modules ./node_modules
COPY --from=build --chown=nodejs:nodejs /app/dist ./dist
COPY --from=build --chown=nodejs:nodejs /app/package.json ./package.json

EXPOSE 3000
CMD ["node", "dist/index.js"]

2. .dockerignore Efficace

# .dockerignore
node_modules
npm-debug.log
Dockerfile
.dockerignore
.git
.gitignore
README.md
.env
.nyc_output
coverage
.nyc_output
.coverage
.pytest_cache
__pycache__
.vscode
.idea
*.md
tests/
docs/
.github/

3. Health Checks

# Dockerfile avec health check
FROM node:18-alpine

WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production

COPY . .

EXPOSE 3000

# Health check
HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
  CMD curl -f http://localhost:3000/health || exit 1

CMD ["npm", "start"]

// Health check endpoint
app.get('/health', (req, res) => {
  res.status(200).json({
    status: 'healthy',
    timestamp: new Date().toISOString(),
    uptime: process.uptime()
  });
});

Patterns Avancés

1. Configuration par Variables d'Environnement

# docker-compose.override.yml (développement)
version: '3.8'

services:
  app:
    environment:
      - NODE_ENV=development
      - LOG_LEVEL=debug
      - DB_HOST=localhost
    volumes:
      - .:/app
      - /app/node_modules

# docker-compose.prod.yml (production)
version: '3.8'

services:
  app:
    environment:
      - NODE_ENV=production
      - LOG_LEVEL=info
    deploy:
      replicas: 3
      resources:
        limits:
          memory: 512M
        reservations:
          memory: 256M

2. Secrets et Configuration Sécurisée

# docker-compose.yml avec secrets
version: '3.8'

services:
  app:
    image: myapp:latest
    secrets:
      - db_password
      - api_key
    environment:
      - DB_PASSWORD_FILE=/run/secrets/db_password
      - API_KEY_FILE=/run/secrets/api_key

secrets:
  db_password:
    file: ./secrets/db_password.txt
  api_key:
    external: true

// Lecture des secrets dans l'application
const fs = require('fs');

function readSecret(secretName) {
  try {
    return fs.readFileSync(`/run/secrets/${secretName}`, 'utf8').trim();
  } catch (error) {
    console.error(`Failed to read secret ${secretName}:`, error);
    return process.env[secretName.toUpperCase()];
  }
}

const dbPassword = readSecret('db_password');
const apiKey = readSecret('api_key');

3. Scaling et Load Balancing

# docker-compose.scale.yml
version: '3.8'

services:
  app:
    image: myapp:latest
    deploy:
      replicas: 3
      update_config:
        parallelism: 1
        delay: 10s
      restart_policy:
        condition: on-failure
    networks:
      - app-network

  nginx:
    image: nginx:alpine
    ports:
      - "80:80"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
    depends_on:
      - app
    networks:
      - app-network

Monitoring et Debugging

1. Logs et Monitoring

# docker-compose.monitoring.yml
version: '3.8'

services:
  app:
    logging:
      driver: "json-file"
      options:
        max-size: "10m"
        max-file: "3"

  prometheus:
    image: prom/prometheus
    ports:
      - "9090:9090"
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml

  grafana:
    image: grafana/grafana
    ports:
      - "3001:3000"
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=admin

2. Debugging avec Docker

# Accéder au shell d'un conteneur
docker exec -it myapp-container /bin/sh

# Voir les logs en temps réel
docker logs -f myapp-container

# Inspecter un conteneur
docker inspect myapp-container

# Statistiques des ressources
docker stats myapp-container

# Debugging d'une image
docker run -it --entrypoint /bin/sh myapp:latest

Production et Déploiement

1. Image de Production Optimisée

FROM node:18-alpine AS production

# Sécurité : utilisateur non-root
RUN addgroup -g 1001 -S nodejs && \
    adduser -S nodejs -u 1001

# Optimisations
RUN apk add --no-cache dumb-init

WORKDIR /app
COPY --chown=nodejs:nodejs package*.json ./
RUN npm ci --only=production && npm cache clean --force

COPY --chown=nodejs:nodejs . .

USER nodejs

EXPOSE 3000
ENTRYPOINT ["dumb-init", "--"]
CMD ["node", "index.js"]

2. Pipeline CI/CD avec Docker

# .github/workflows/docker.yml
name: Docker Build and Deploy

on:
  push:
    branches: [main]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v3

      - name: Login to DockerHub
        uses: docker/login-action@v3
        with:
          username: ${{ secrets.DOCKER_USERNAME }}
          password: ${{ secrets.DOCKER_TOKEN }}

      - name: Build and push
        uses: docker/build-push-action@v5
        with:
          context: .
          push: true
          tags: myapp:${{ github.sha }},myapp:latest
          cache-from: type=gha
          cache-to: type=gha,mode=max

Commandes Utiles

# Construction et gestion
docker build -t myapp:latest .
docker-compose up -d --build
docker-compose down -v

# Nettoyage
docker system prune -a
docker volume prune
docker network prune

# Debugging
docker-compose logs -f app
docker-compose exec app sh
docker inspect <container_id>

# Scaling
docker-compose up -d --scale app=3

# Backup et restore
docker-compose exec postgres pg_dump -U postgres myapp > backup.sql
docker-compose exec -T postgres psql -U postgres myapp < backup.sql

Conclusion

Docker transforme le développement backend en offrant :

Cohérence des environnements de développement à production
Isolation et portabilité des applications
Simplification du déploiement et de la scalabilité
Amélioration de la collaboration en équipe
Facilitation des tests et de l'intégration continue

Maîtriser Docker est devenu essentiel pour tout développeur backend moderne. L'investissement en temps d'apprentissage est rapidement rentabilisé par la productivité et la fiabilité apportées.

Gemini 3.5 Flash

Ulrich (Houngbe) — Wed, 20 May 2026 12:18:11 +0000

I watched the Google I/O 2026 Developer Keynote, and honestly… the launch of Gemini 3.5 surprised me in more ways than one.

This model is faster AND more powerful than Gemini 1.5 Pro on nearly all benchmarks—including reasoning, coding, and long-running tasks.

What’s impressive is the performance-to-price ratio: it costs less than half the price of comparable models on the market. Ideal for those who want to integrate AI into their products without blowing their API budget.

Gemini 3.5 Flash is already available now on all Google products and APIs. And Gemini 3.5 Pro, even more powerful, is coming in June.

The era of agents has just accelerated.

youtube link

CI/CD avec GitHub Actions

Ulrich (Houngbe) — Wed, 20 May 2026 10:43:39 +0000

CI/CD avec GitHub Actions : Guide Complet

GitHub Actions révolutionne l'intégration et le déploiement continus en intégrant directement ces fonctionnalités dans votre repository GitHub. Ce guide vous accompagne dans la mise en place d'une pipeline CI/CD robuste.

Qu'est-ce que GitHub Actions ?

GitHub Actions est une plateforme d'automatisation qui permet de :

Exécuter des workflows basés sur des événements
Automatiser les tests, builds et déploiements
Créer des actions personnalisées réutilisables
S'intégrer parfaitement avec l'écosystème GitHub

Concepts Fondamentaux

1. Composants Clés

Workflow : Processus automatisé défini dans un fichier YAML
Job : Ensemble de steps qui s'exécutent sur un runner
Step : Action individuelle (commande ou action)
Runner : Machine virtuelle qui exécute les jobs
Action : Application réutilisable qui effectue une tâche

2. Structure d'un Workflow

name: CI/CD Pipeline

on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '18'
      - name: Install dependencies
        run: npm ci
      - name: Run tests
        run: npm test

Pipeline CI Complète

1. Workflow Python avec Tests

name: Python CI

on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main]

jobs:
  lint:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Set up Python
        uses: actions/setup-python@v4
        with:
          python-version: '3.11'

      - name: Cache pip dependencies
        uses: actions/cache@v3
        with:
          path: ~/.cache/pip
          key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt') }}
          restore-keys: |
            ${{ runner.os }}-pip-

      - name: Install dependencies
        run: |
          python -m pip install --upgrade pip
          pip install flake8 black mypy
          pip install -r requirements.txt

      - name: Lint with flake8
        run: |
          flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
          flake8 . --count --exit-zero --max-complexity=10 --max-line-length=88 --statistics

      - name: Format check with black
        run: black --check .

      - name: Type check with mypy
        run: mypy src/

  test:
    needs: lint
    runs-on: ubuntu-latest
    strategy:
      matrix:
        python-version: ['3.9', '3.10', '3.11']

    steps:
      - uses: actions/checkout@v4

      - name: Set up Python ${{ matrix.python-version }}
        uses: actions/setup-python@v4
        with:
          python-version: ${{ matrix.python-version }}

      - name: Install dependencies
        run: |
          python -m pip install --upgrade pip
          pip install pytest pytest-cov
          pip install -r requirements.txt

      - name: Run tests with coverage
        run: |
          pytest --cov=src --cov-report=xml --cov-report=html

      - name: Upload coverage to Codecov
        uses: codecov/codecov-action@v3
        with:
          file: ./coverage.xml
          flags: unittests
          name: codecov-umbrella

  security:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Run security scan
        uses: pypa/gh-action-pip-audit@v1.0.8
        with:
          inputs: requirements.txt

      - name: Run Bandit security check
        run: |
          pip install bandit
          bandit -r src/ -f json -o bandit-report.json

      - name: Upload security report
        uses: actions/upload-artifact@v4
        if: always()
        with:
          name: security-report
          path: bandit-report.json

2. Workflow Node.js/React

name: Node.js CI/CD

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  test:
    runs-on: ubuntu-latest

    strategy:
      matrix:
        node-version: [16, 18, 20]

    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Use Node.js ${{ matrix.node-version }}
        uses: actions/setup-node@v4
        with:
          node-version: ${{ matrix.node-version }}
          cache: 'npm'

      - name: Install dependencies
        run: npm ci

      - name: Run linting
        run: npm run lint

      - name: Run type checking
        run: npm run type-check

      - name: Run unit tests
        run: npm test -- --coverage --watchAll=false

      - name: Run integration tests
        run: npm run test:integration

      - name: Build application
        run: npm run build

      - name: Upload build artifacts
        uses: actions/upload-artifact@v4
        with:
          name: build-files-${{ matrix.node-version }}
          path: dist/

  e2e-tests:
    needs: test
    runs-on: ubuntu-latest

    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '18'
          cache: 'npm'

      - name: Install dependencies
        run: npm ci

      - name: Install Playwright
        run: npx playwright install --with-deps

      - name: Start application
        run: |
          npm run build
          npm run start &
          sleep 30

      - name: Run Playwright tests
        run: npx playwright test

      - name: Upload test results
        uses: actions/upload-artifact@v4
        if: always()
        with:
          name: playwright-report
          path: playwright-report/

Pipeline CD avec Déploiement

1. Déploiement sur AWS

name: Deploy to AWS

on:
  push:
    branches: [main]
  workflow_dispatch:

jobs:
  deploy:
    runs-on: ubuntu-latest
    environment: production

    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Configure AWS credentials
        uses: aws-actions/configure-aws-credentials@v4
        with:
          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
          aws-region: us-east-1

      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '18'
          cache: 'npm'

      - name: Install dependencies
        run: npm ci

      - name: Build application
        run: npm run build
        env:
          REACT_APP_API_URL: ${{ secrets.API_URL }}
          REACT_APP_ENV: production

      - name: Deploy to S3
        run: |
          aws s3 sync dist/ s3://${{ secrets.S3_BUCKET }} --delete

      - name: Invalidate CloudFront
        run: |
          aws cloudfront create-invalidation \
            --distribution-id ${{ secrets.CLOUDFRONT_DISTRIBUTION_ID }} \
            --paths "/*"

      - name: Notify Slack
        if: always()
        uses: 8398a7/action-slack@v3
        with:
          status: ${{ job.status }}
          channel: '#deployments'
          webhook_url: ${{ secrets.SLACK_WEBHOOK_URL }}

2. Déploiement Docker

name: Docker Build and Deploy

on:
  push:
    branches: [main]
    tags: ['v*']

env:
  REGISTRY: ghcr.io
  IMAGE_NAME: ${{ github.repository }}

jobs:
  build-and-push:
    runs-on: ubuntu-latest
    permissions:
      contents: read
      packages: write

    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v3

      - name: Log in to Container Registry
        uses: docker/login-action@v3
        with:
          registry: ${{ env.REGISTRY }}
          username: ${{ github.actor }}
          password: ${{ secrets.GITHUB_TOKEN }}

      - name: Extract metadata
        id: meta
        uses: docker/metadata-action@v5
        with:
          images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
          tags: |
            type=ref,event=branch
            type=ref,event=pr
            type=semver,pattern={{version}}
            type=semver,pattern={{major}}.{{minor}}

      - name: Build and push Docker image
        uses: docker/build-push-action@v5
        with:
          context: .
          push: true
          tags: ${{ steps.meta.outputs.tags }}
          labels: ${{ steps.meta.outputs.labels }}
          cache-from: type=gha
          cache-to: type=gha,mode=max

      - name: Deploy to staging
        if: github.ref == 'refs/heads/main'
        run: |
          echo "Deploying to staging environment"
          # Commandes de déploiement ici

Workflows Avancés

1. Matrix Strategy avec Conditions

name: Cross-platform Testing

on: [push, pull_request]

jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        os: [ubuntu-latest, windows-latest, macos-latest]
        python-version: ['3.9', '3.10', '3.11']
        exclude:
          - os: windows-latest
            python-version: '3.9'

    runs-on: ${{ matrix.os }}

    steps:
      - uses: actions/checkout@v4

      - name: Set up Python ${{ matrix.python-version }}
        uses: actions/setup-python@v4
        with:
          python-version: ${{ matrix.python-version }}

      - name: Install dependencies (Unix)
        if: runner.os != 'Windows'
        run: |
          python -m pip install --upgrade pip
          pip install -r requirements.txt

      - name: Install dependencies (Windows)
        if: runner.os == 'Windows'
        run: |
          python -m pip install --upgrade pip
          pip install -r requirements.txt
        shell: cmd

      - name: Run tests
        run: pytest

2. Déploiement Multi-Environnement

name: Multi-Environment Deploy

on:
  push:
    branches: [main, develop]

jobs:
  deploy-staging:
    if: github.ref == 'refs/heads/develop'
    runs-on: ubuntu-latest
    environment:
      name: staging
      url: https://staging.example.com

    steps:
      - name: Deploy to Staging
        run: |
          echo "Deploying to staging"
          # Logique de déploiement staging

  deploy-production:
    if: github.ref == 'refs/heads/main'
    runs-on: ubuntu-latest
    environment:
      name: production
      url: https://example.com

    steps:
      - name: Deploy to Production
        run: |
          echo "Deploying to production"
          # Logique de déploiement production

Actions Personnalisées

1. Action Composite

# .github/actions/setup-node-cache/action.yml
name: 'Setup Node with Cache'
description: 'Setup Node.js with dependency caching'

inputs:
  node-version:
    description: 'Node.js version'
    required: false
    default: '18'
  working-directory:
    description: 'Working directory'
    required: false
    default: '.'

runs:
  using: 'composite'
  steps:
    - name: Setup Node.js
      uses: actions/setup-node@v4
      with:
        node-version: ${{ inputs.node-version }}
        cache: 'npm'
        cache-dependency-path: ${{ inputs.working-directory }}/package-lock.json

    - name: Install dependencies
      working-directory: ${{ inputs.working-directory }}
      run: npm ci
      shell: bash

2. Usage de l'Action

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Setup Node.js with cache
        uses: ./.github/actions/setup-node-cache
        with:
          node-version: '18'
          working-directory: './frontend'

Bonnes Pratiques

1. Sécurité

# Utilisation des secrets
steps:
  - name: Deploy with secrets
    env:
      API_KEY: ${{ secrets.API_KEY }}
      DB_PASSWORD: ${{ secrets.DB_PASSWORD }}
    run: |
      echo "API_KEY is set: ${API_KEY:+yes}"
      # Utiliser les secrets de manière sécurisée

2. Optimisation des Performances

# Cache des dépendances
- name: Cache dependencies
  uses: actions/cache@v3
  with:
    path: |
      ~/.npm
      node_modules
    key: ${{ runner.os }}-npm-${{ hashFiles('**/package-lock.json') }}
    restore-keys: |
      ${{ runner.os }}-npm-

# Parallélisation des jobs
jobs:
  lint:
    runs-on: ubuntu-latest
  test:
    runs-on: ubuntu-latest
  build:
    needs: [lint, test]
    runs-on: ubuntu-latest

3. Monitoring et Notifications

  - name: Notify on failure
    if: failure()
    uses: actions/github-script@v7
    with:
      script: |
        github.rest.issues.createComment({
          issue_number: context.issue.number,
          owner: context.repo.owner,
          repo: context.repo.repo,
          body: '❌ Pipeline failed! Please check the logs.'
        })

Conclusion

GitHub Actions offre une solution puissante et flexible pour l'automatisation :

Intégration native avec GitHub
Écosystème riche d'actions réutilisables
Scaling automatique des runners
Support multi-plateforme
Gestion fine des permissions

Une pipeline bien conçue améliore la qualité du code, réduit les risques de déploiement et accélère le cycle de développement. L'investissement initial en configuration est rapidement rentabilisé par la réduction des erreurs et l'automatisation des tâches répétitives.

CI/CD avec GitHub Actions

Ulrich (Houngbe) — Wed, 20 May 2026 08:50:45 +0000

CI/CD avec GitHub Actions : Guide Complet

Qu'est-ce que GitHub Actions ?

GitHub Actions est une plateforme d'automatisation qui permet de :

Exécuter des workflows basés sur des événements
Automatiser les tests, builds et déploiements
Créer des actions personnalisées réutilisables
S'intégrer parfaitement avec l'écosystème GitHub

Concepts Fondamentaux

1. Composants Clés

Workflow : Processus automatisé défini dans un fichier YAML
Job : Ensemble de steps qui s'exécutent sur un runner
Step : Action individuelle (commande ou action)
Runner : Machine virtuelle qui exécute les jobs
Action : Application réutilisable qui effectue une tâche

2. Structure d'un Workflow

name: CI/CD Pipeline

on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '18'
      - name: Install dependencies
        run: npm ci
      - name: Run tests
        run: npm test

Pipeline CI Complète

1. Workflow Python avec Tests

name: Python CI

on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main]

jobs:
  lint:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Set up Python
        uses: actions/setup-python@v4
        with:
          python-version: '3.11'

      - name: Cache pip dependencies
        uses: actions/cache@v3
        with:
          path: ~/.cache/pip
          key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt') }}
          restore-keys: |
            ${{ runner.os }}-pip-

      - name: Install dependencies
        run: |
          python -m pip install --upgrade pip
          pip install flake8 black mypy
          pip install -r requirements.txt

      - name: Lint with flake8
        run: |
          flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
          flake8 . --count --exit-zero --max-complexity=10 --max-line-length=88 --statistics

      - name: Format check with black
        run: black --check .

      - name: Type check with mypy
        run: mypy src/

  test:
    needs: lint
    runs-on: ubuntu-latest
    strategy:
      matrix:
        python-version: ['3.9', '3.10', '3.11']

    steps:
      - uses: actions/checkout@v4

      - name: Set up Python ${{ matrix.python-version }}
        uses: actions/setup-python@v4
        with:
          python-version: ${{ matrix.python-version }}

      - name: Install dependencies
        run: |
          python -m pip install --upgrade pip
          pip install pytest pytest-cov
          pip install -r requirements.txt

      - name: Run tests with coverage
        run: |
          pytest --cov=src --cov-report=xml --cov-report=html

      - name: Upload coverage to Codecov
        uses: codecov/codecov-action@v3
        with:
          file: ./coverage.xml
          flags: unittests
          name: codecov-umbrella

  security:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Run security scan
        uses: pypa/gh-action-pip-audit@v1.0.8
        with:
          inputs: requirements.txt

      - name: Run Bandit security check
        run: |
          pip install bandit
          bandit -r src/ -f json -o bandit-report.json

      - name: Upload security report
        uses: actions/upload-artifact@v4
        if: always()
        with:
          name: security-report
          path: bandit-report.json

2. Workflow Node.js/React

name: Node.js CI/CD

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  test:
    runs-on: ubuntu-latest

    strategy:
      matrix:
        node-version: [16, 18, 20]

    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Use Node.js ${{ matrix.node-version }}
        uses: actions/setup-node@v4
        with:
          node-version: ${{ matrix.node-version }}
          cache: 'npm'

      - name: Install dependencies
        run: npm ci

      - name: Run linting
        run: npm run lint

      - name: Run type checking
        run: npm run type-check

      - name: Run unit tests
        run: npm test -- --coverage --watchAll=false

      - name: Run integration tests
        run: npm run test:integration

      - name: Build application
        run: npm run build

      - name: Upload build artifacts
        uses: actions/upload-artifact@v4
        with:
          name: build-files-${{ matrix.node-version }}
          path: dist/

  e2e-tests:
    needs: test
    runs-on: ubuntu-latest

    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '18'
          cache: 'npm'

      - name: Install dependencies
        run: npm ci

      - name: Install Playwright
        run: npx playwright install --with-deps

      - name: Start application
        run: |
          npm run build
          npm run start &
          sleep 30

      - name: Run Playwright tests
        run: npx playwright test

      - name: Upload test results
        uses: actions/upload-artifact@v4
        if: always()
        with:
          name: playwright-report
          path: playwright-report/

Pipeline CD avec Déploiement

1. Déploiement sur AWS

name: Deploy to AWS

on:
  push:
    branches: [main]
  workflow_dispatch:

jobs:
  deploy:
    runs-on: ubuntu-latest
    environment: production

    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Configure AWS credentials
        uses: aws-actions/configure-aws-credentials@v4
        with:
          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
          aws-region: us-east-1

      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '18'
          cache: 'npm'

      - name: Install dependencies
        run: npm ci

      - name: Build application
        run: npm run build
        env:
          REACT_APP_API_URL: ${{ secrets.API_URL }}
          REACT_APP_ENV: production

      - name: Deploy to S3
        run: |
          aws s3 sync dist/ s3://${{ secrets.S3_BUCKET }} --delete

      - name: Invalidate CloudFront
        run: |
          aws cloudfront create-invalidation \
            --distribution-id ${{ secrets.CLOUDFRONT_DISTRIBUTION_ID }} \
            --paths "/*"

      - name: Notify Slack
        if: always()
        uses: 8398a7/action-slack@v3
        with:
          status: ${{ job.status }}
          channel: '#deployments'
          webhook_url: ${{ secrets.SLACK_WEBHOOK_URL }}

2. Déploiement Docker

name: Docker Build and Deploy

on:
  push:
    branches: [main]
    tags: ['v*']

env:
  REGISTRY: ghcr.io
  IMAGE_NAME: ${{ github.repository }}

jobs:
  build-and-push:
    runs-on: ubuntu-latest
    permissions:
      contents: read
      packages: write

    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v3

      - name: Log in to Container Registry
        uses: docker/login-action@v3
        with:
          registry: ${{ env.REGISTRY }}
          username: ${{ github.actor }}
          password: ${{ secrets.GITHUB_TOKEN }}

      - name: Extract metadata
        id: meta
        uses: docker/metadata-action@v5
        with:
          images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
          tags: |
            type=ref,event=branch
            type=ref,event=pr
            type=semver,pattern={{version}}
            type=semver,pattern={{major}}.{{minor}}

      - name: Build and push Docker image
        uses: docker/build-push-action@v5
        with:
          context: .
          push: true
          tags: ${{ steps.meta.outputs.tags }}
          labels: ${{ steps.meta.outputs.labels }}
          cache-from: type=gha
          cache-to: type=gha,mode=max

      - name: Deploy to staging
        if: github.ref == 'refs/heads/main'
        run: |
          echo "Deploying to staging environment"
          # Commandes de déploiement ici

Workflows Avancés

1. Matrix Strategy avec Conditions

name: Cross-platform Testing

on: [push, pull_request]

jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        os: [ubuntu-latest, windows-latest, macos-latest]
        python-version: ['3.9', '3.10', '3.11']
        exclude:
          - os: windows-latest
            python-version: '3.9'

    runs-on: ${{ matrix.os }}

    steps:
      - uses: actions/checkout@v4

      - name: Set up Python ${{ matrix.python-version }}
        uses: actions/setup-python@v4
        with:
          python-version: ${{ matrix.python-version }}

      - name: Install dependencies (Unix)
        if: runner.os != 'Windows'
        run: |
          python -m pip install --upgrade pip
          pip install -r requirements.txt

      - name: Install dependencies (Windows)
        if: runner.os == 'Windows'
        run: |
          python -m pip install --upgrade pip
          pip install -r requirements.txt
        shell: cmd

      - name: Run tests
        run: pytest

2. Déploiement Multi-Environnement

name: Multi-Environment Deploy

on:
  push:
    branches: [main, develop]

jobs:
  deploy-staging:
    if: github.ref == 'refs/heads/develop'
    runs-on: ubuntu-latest
    environment:
      name: staging
      url: https://staging.example.com

    steps:
      - name: Deploy to Staging
        run: |
          echo "Deploying to staging"
          # Logique de déploiement staging

  deploy-production:
    if: github.ref == 'refs/heads/main'
    runs-on: ubuntu-latest
    environment:
      name: production
      url: https://example.com

    steps:
      - name: Deploy to Production
        run: |
          echo "Deploying to production"
          # Logique de déploiement production

Actions Personnalisées

1. Action Composite

# .github/actions/setup-node-cache/action.yml
name: 'Setup Node with Cache'
description: 'Setup Node.js with dependency caching'

inputs:
  node-version:
    description: 'Node.js version'
    required: false
    default: '18'
  working-directory:
    description: 'Working directory'
    required: false
    default: '.'

runs:
  using: 'composite'
  steps:
    - name: Setup Node.js
      uses: actions/setup-node@v4
      with:
        node-version: ${{ inputs.node-version }}
        cache: 'npm'
        cache-dependency-path: ${{ inputs.working-directory }}/package-lock.json

    - name: Install dependencies
      working-directory: ${{ inputs.working-directory }}
      run: npm ci
      shell: bash

2. Usage de l'Action

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Setup Node.js with cache
        uses: ./.github/actions/setup-node-cache
        with:
          node-version: '18'
          working-directory: './frontend'

Bonnes Pratiques

1. Sécurité

# Utilisation des secrets
steps:
  - name: Deploy with secrets
    env:
      API_KEY: ${{ secrets.API_KEY }}
      DB_PASSWORD: ${{ secrets.DB_PASSWORD }}
    run: |
      echo "API_KEY is set: ${API_KEY:+yes}"
      # Utiliser les secrets de manière sécurisée

2. Optimisation des Performances

# Cache des dépendances
- name: Cache dependencies
  uses: actions/cache@v3
  with:
    path: |
      ~/.npm
      node_modules
    key: ${{ runner.os }}-npm-${{ hashFiles('**/package-lock.json') }}
    restore-keys: |
      ${{ runner.os }}-npm-

# Parallélisation des jobs
jobs:
  lint:
    runs-on: ubuntu-latest
  test:
    runs-on: ubuntu-latest
  build:
    needs: [lint, test]
    runs-on: ubuntu-latest

3. Monitoring et Notifications

  - name: Notify on failure
    if: failure()
    uses: actions/github-script@v7
    with:
      script: |
        github.rest.issues.createComment({
          issue_number: context.issue.number,
          owner: context.repo.owner,
          repo: context.repo.repo,
          body: '❌ Pipeline failed! Please check the logs.'
        })

Conclusion

GitHub Actions offre une solution puissante et flexible pour l'automatisation :

Intégration native avec GitHub
Écosystème riche d'actions réutilisables
Scaling automatique des runners
Support multi-plateforme
Gestion fine des permissions

Les Design Patterns essentiels

Ulrich (Houngbe) — Tue, 19 May 2026 16:01:21 +0000

Les Design Patterns Essentiels : Guide du Développeur

Les design patterns sont des solutions éprouvées à des problèmes récurrents en programmation. Ils représentent les meilleures pratiques développées par des générations de programmeurs.

Qu'est-ce qu'un Design Pattern ?

Un design pattern décrit :

Un problème récurrent
Une solution générale réutilisable
Les conséquences de cette solution

Les Patterns Essentiels

1. Singleton Pattern

Problème : Garantir qu'une classe n'a qu'une seule instance.

class DatabaseConnection:
    _instance = None
    _initialized = False

    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
        return cls._instance

    def __init__(self):
        if not self._initialized:
            self.connection = self._create_connection()
            self._initialized = True

    def _create_connection(self):
        # Simulation de connexion
        return "Connection établie"

    def query(self, sql):
        return f"Exécution de : {sql}"

# Usage
db1 = DatabaseConnection()
db2 = DatabaseConnection()
print(db1 is db2)  # True

Version thread-safe :

import threading

class ThreadSafeSingleton:
    _instance = None
    _lock = threading.Lock()

    def __new__(cls):
        if cls._instance is None:
            with cls._lock:
                if cls._instance is None:
                    cls._instance = super().__new__(cls)
        return cls._instance

2. Factory Pattern

Problème : Créer des objets sans spécifier leur classe exacte.

from abc import ABC, abstractmethod

class Animal(ABC):
    @abstractmethod
    def make_sound(self):
        pass

class Dog(Animal):
    def make_sound(self):
        return "Woof!"

class Cat(Animal):
    def make_sound(self):
        return "Meow!"

class Bird(Animal):
    def make_sound(self):
        return "Tweet!"

class AnimalFactory:
    @staticmethod
    def create_animal(animal_type: str) -> Animal:
        animals = {
            'dog': Dog,
            'cat': Cat,
            'bird': Bird
        }

        animal_class = animals.get(animal_type.lower())
        if animal_class:
            return animal_class()
        else:
            raise ValueError(f"Type d'animal inconnu: {animal_type}")

# Usage
factory = AnimalFactory()
dog = factory.create_animal('dog')
cat = factory.create_animal('cat')

print(dog.make_sound())  # Woof!
print(cat.make_sound())  # Meow!

3. Observer Pattern

Problème : Notifier plusieurs objets lors d'un changement d'état.

from abc import ABC, abstractmethod
from typing import List

class Observer(ABC):
    @abstractmethod
    def update(self, message: str):
        pass

class Subject:
    def __init__(self):
        self._observers: List[Observer] = []

    def attach(self, observer: Observer):
        if observer not in self._observers:
            self._observers.append(observer)

    def detach(self, observer: Observer):
        if observer in self._observers:
            self._observers.remove(observer)

    def notify(self, message: str):
        for observer in self._observers:
            observer.update(message)

class EmailNotifier(Observer):
    def __init__(self, email: str):
        self.email = email

    def update(self, message: str):
        print(f"Email envoyé à {self.email}: {message}")

class SMSNotifier(Observer):
    def __init__(self, phone: str):
        self.phone = phone

    def update(self, message: str):
        print(f"SMS envoyé au {self.phone}: {message}")

class NewsPublisher(Subject):
    def __init__(self):
        super().__init__()
        self._latest_news = ""

    def publish_news(self, news: str):
        self._latest_news = news
        self.notify(f"Nouvelle actualité: {news}")

# Usage
publisher = NewsPublisher()

email_notifier = EmailNotifier("user@example.com")
sms_notifier = SMSNotifier("+33612345678")

publisher.attach(email_notifier)
publisher.attach(sms_notifier)

publisher.publish_news("Nouvelle fonctionnalité lancée!")

4. Strategy Pattern

Problème : Choisir un algorithme à l'exécution.

from abc import ABC, abstractmethod

class PaymentStrategy(ABC):
    @abstractmethod
    def pay(self, amount: float) -> str:
        pass

class CreditCardPayment(PaymentStrategy):
    def __init__(self, card_number: str):
        self.card_number = card_number

    def pay(self, amount: float) -> str:
        return f"Paiement de {amount}€ par carte {self.card_number[-4:]}"

class PayPalPayment(PaymentStrategy):
    def __init__(self, email: str):
        self.email = email

    def pay(self, amount: float) -> str:
        return f"Paiement de {amount}€ via PayPal ({self.email})"

class BankTransferPayment(PaymentStrategy):
    def __init__(self, account_number: str):
        self.account_number = account_number

    def pay(self, amount: float) -> str:
        return f"Virement de {amount}€ vers {self.account_number}"

class ShoppingCart:
    def __init__(self):
        self.items = []
        self.payment_strategy = None

    def add_item(self, item: str, price: float):
        self.items.append((item, price))

    def set_payment_strategy(self, strategy: PaymentStrategy):
        self.payment_strategy = strategy

    def checkout(self):
        total = sum(price for _, price in self.items)
        if self.payment_strategy:
            return self.payment_strategy.pay(total)
        else:
            raise ValueError("Aucune stratégie de paiement définie")

# Usage
cart = ShoppingCart()
cart.add_item("Laptop", 999.99)
cart.add_item("Souris", 29.99)

# Paiement par carte
cart.set_payment_strategy(CreditCardPayment("1234567812345678"))
print(cart.checkout())

# Changement de stratégie
cart.set_payment_strategy(PayPalPayment("user@example.com"))
print(cart.checkout())

5. Decorator Pattern

Problème : Ajouter des fonctionnalités à un objet dynamiquement.

from abc import ABC, abstractmethod

class Coffee(ABC):
    @abstractmethod
    def cost(self) -> float:
        pass

    @abstractmethod
    def description(self) -> str:
        pass

class SimpleCoffee(Coffee):
    def cost(self) -> float:
        return 2.0

    def description(self) -> str:
        return "Café simple"

class CoffeeDecorator(Coffee):
    def __init__(self, coffee: Coffee):
        self._coffee = coffee

class MilkDecorator(CoffeeDecorator):
    def cost(self) -> float:
        return self._coffee.cost() + 0.5

    def description(self) -> str:
        return self._coffee.description() + " + lait"

class SugarDecorator(CoffeeDecorator):
    def cost(self) -> float:
        return self._coffee.cost() + 0.2

    def description(self) -> str:
        return self._coffee.description() + " + sucre"

class VanillaDecorator(CoffeeDecorator):
    def cost(self) -> float:
        return self._coffee.cost() + 0.8

    def description(self) -> str:
        return self._coffee.description() + " + vanille"

# Usage
coffee = SimpleCoffee()
print(f"{coffee.description()}: {coffee.cost()}€")

# Ajout de lait
coffee_with_milk = MilkDecorator(coffee)
print(f"{coffee_with_milk.description()}: {coffee_with_milk.cost()}€")

# Ajout de sucre et vanille
fancy_coffee = VanillaDecorator(SugarDecorator(coffee_with_milk))
print(f"{fancy_coffee.description()}: {fancy_coffee.cost()}€")

6. Command Pattern

Problème : Encapsuler une requête comme un objet.

from abc import ABC, abstractmethod
from typing import List

class Command(ABC):
    @abstractmethod
    def execute(self):
        pass

    @abstractmethod
    def undo(self):
        pass

class Light:
    def __init__(self, location: str):
        self.location = location
        self.is_on = False

    def turn_on(self):
        self.is_on = True
        print(f"Lumière {self.location} allumée")

    def turn_off(self):
        self.is_on = False
        print(f"Lumière {self.location} éteinte")

class LightOnCommand(Command):
    def __init__(self, light: Light):
        self.light = light

    def execute(self):
        self.light.turn_on()

    def undo(self):
        self.light.turn_off()

class LightOffCommand(Command):
    def __init__(self, light: Light):
        self.light = light

    def execute(self):
        self.light.turn_off()

    def undo(self):
        self.light.turn_on()

class RemoteControl:
    def __init__(self):
        self.commands: List[Command] = []
        self.last_command: Command = None

    def set_command(self, command: Command):
        self.commands.append(command)

    def press_button(self, slot: int):
        if 0 <= slot < len(self.commands):
            command = self.commands[slot]
            command.execute()
            self.last_command = command

    def press_undo(self):
        if self.last_command:
            self.last_command.undo()

# Usage
living_room_light = Light("salon")
bedroom_light = Light("chambre")

remote = RemoteControl()
remote.set_command(LightOnCommand(living_room_light))
remote.set_command(LightOffCommand(living_room_light))
remote.set_command(LightOnCommand(bedroom_light))

remote.press_button(0)  # Allume le salon
remote.press_button(2)  # Allume la chambre
remote.press_undo()     # Annule la dernière action

Patterns Avancés

7. Builder Pattern

class Pizza:
    def __init__(self):
        self.size = ""
        self.dough = ""
        self.toppings = []

    def __str__(self):
        return f"Pizza {self.size}, pâte {self.dough}, garnie de: {', '.join(self.toppings)}"

class PizzaBuilder:
    def __init__(self):
        self.pizza = Pizza()

    def set_size(self, size: str):
        self.pizza.size = size
        return self

    def set_dough(self, dough: str):
        self.pizza.dough = dough
        return self

    def add_topping(self, topping: str):
        self.pizza.toppings.append(topping)
        return self

    def build(self) -> Pizza:
        return self.pizza

# Usage
pizza = (PizzaBuilder()
         .set_size("grande")
         .set_dough("fine")
         .add_topping("mozzarella")
         .add_topping("tomates")
         .add_topping("basilic")
         .build())

print(pizza)

Quand Utiliser Chaque Pattern

Pattern	Utilisation	Avantages
Singleton	Configuration globale	Une seule instance
Factory	Création d'objets complexes	Flexibilité
Observer	Notifications	Couplage faible
Strategy	Algorithmes interchangeables	Extensibilité
Decorator	Fonctionnalités additionnelles	Composition
Command	Actions réversibles	Historique

Anti-Patterns à Éviter

1. Singletons Partout

# Mauvais
class Logger(Singleton):
    pass

class Config(Singleton):
    pass

# Mieux : Injection de dépendance
class Service:
    def __init__(self, logger: Logger, config: Config):
        self.logger = logger
        self.config = config

2. Factory Trop Complexe

# Mauvais
class ComplexFactory:
    def create(self, type, size, color, material, style, ...):
        # Trop de paramètres
        pass

# Mieux : Builder Pattern
class ProductBuilder:
    def with_size(self, size): return self
    def with_color(self, color): return self
    # ...

Conclusion

Les design patterns sont des outils puissants qui :

Améliorent la communication entre développeurs
Fournissent des solutions éprouvées
Rendent le code plus maintenable
Facilitent les tests et la refactorisation

L'important n'est pas de tous les connaître, mais de comprendre quand et comment les appliquer. Un bon développeur sait reconnaître les situations où un pattern apporte une réelle valeur ajoutée.