Test Technique Axel

Évaluation Technique - Application Symfony de Gestion d'Outils

4 min de lecture

Évaluation Technique - Application Symfony de Gestion d’Outils

Informations Générales

Candidat : Axel
Projet : Application Symfony - Gestion d’outils internes
Date d’évaluation : 26 août 2025
Stack technique : Symfony 6.4 LTS / PHP 8.1+ / API Platform 4.1 / Doctrine ORM 3.5

Synthèse des Résultats

Scores Détaillés par Phase

PhaseDescriptionScoreMaximumPourcentage
Phase 1Analyse Initiale6.51065%
Phase 2CRUD API85514.5%
Phase 3Qualité Code264065%
Phase 4Analytics (Bonus)0300%
Phase 5Documentation (Bonus)1520%

Score global : 41.5/140 points (29.6%)
Score base (hors bonus) : 40.5/105 points (38.6%)

Points Forts Identifiés

Maîtrise des Fondamentaux Symfony

Le candidat démontre une compréhension correcte de l’écosystème Symfony moderne :

  • Stack technologique appropriée : Symfony 6.4 LTS, API Platform 4.1, Doctrine ORM 3.5
  • Architecture conforme aux conventions du framework
  • Configuration d’environnement externalisée correctement
  • Intégration cohérente des bundles tiers

Qualité du Code

L’analyse révèle plusieurs aspects positifs dans l’approche de développement :

  • Conventions de nommage (4/4 pts) : Variables et classes nommées de manière appropriée
  • Structure des méthodes (3/3 pts) : Fonctions courtes et lisibles
  • Relations ORM : Associations bidirectionnelles correctement implémentées
  • Types de données : Utilisation appropriée des types DECIMAL, TEXT et contraintes
// Exemple de conventions respectées
private ?string $businessJustification = null;
private ?string $ownerDepartment = null;
private ?int $activeUsersCount = null;

Modélisation des Données

La conception de la base de données témoigne d’une compréhension correcte du métier :

  • 7 entités structurées de manière logique (User, Tool, Category, AccessRequest, etc.)
  • Relations appropriées : Many-to-Many via UserToolAccess
  • Champs métier pertinents : gestion des coûts, départements, suivi d’usage
  • Contraintes définies : nullable, length, joinColumn utilisés correctement

Configuration Technique

L’infrastructure déployée montre une approche méthodique :

  • Configuration Docker avec Compose.yaml et PostgreSQL
  • Système de migrations en place
  • PHPUnit configuré pour les tests
  • Documentation Swagger via Nelmio API Doc

Axes d’Amélioration Critiques

Implémentation API CRUD Incomplète

Constat : L’API présente une couverture fonctionnelle insuffisante avec seulement 1 endpoint opérationnel sur 4.

Problème technique : Absence des endpoints POST et PUT, limitant l’API à des opérations de lecture seule.

Actions correctives recommandées :

// Implémentation requise : POST /api/tools
#[Route('/api/tools', name: 'api_tools_create', methods: ['POST'])]
public function create(Request $request, ValidatorInterface $validator): JsonResponse
{
    // 1. Désérialisation JSON vers entité Tool
    // 2. Validation via Symfony Validator
    // 3. Persistance en base de données
    // 4. Réponse HTTP 201 Created
}
 
// Implémentation requise : PUT /api/tools/{id}
#[Route('/api/tools/{id}', name: 'api_tools_update', methods: ['PUT'])]
public function update(int $id, Request $request): JsonResponse
{
    // 1. Vérification d'existence de la ressource
    // 2. Mise à jour des propriétés
    // 3. Validation des données
    // 4. Réponse HTTP 200 OK
}

Absence de Validation des Données

Lacune identifiée : Aucun mécanisme de validation des données d’entrée implémenté.

Solution recommandée :

use Symfony\Component\Validator\Constraints as Assert;
 
class Tool
{
    #[Assert\NotBlank(message: "Le nom de l'outil est obligatoire")]
    #[Assert\Length(max: 100)]
    private ?string $name = null;
    
    #[Assert\Positive(message: "Le coût doit être positif")]
    private ?string $monthlyCost = null;
}

Architecture - Séparation des Responsabilités

Observation : Logique métier directement intégrée dans les contrôleurs, ne respectant pas le principe de séparation des couches.

Pattern recommandé :

// Création : src/Service/ToolService.php
class ToolService 
{
    public function createTool(array $data): Tool
    {
        // Logique métier de création
        // Règles de validation business
        // Calculs automatiques
    }
    
    public function findToolsWithFilters(array $filters): array
    {
        // Logique de filtrage avancée
        // Gestion de la pagination
        // Tri des résultats
    }
}

Documentation Projet

Manquement constaté : Absence de documentation technique (README.md).

Livrable à produire :

# Tool Management API
 
## Installation
```bash
cd back/
composer install
docker-compose up -d
symfony serve

Documentation API

http://localhost:8000/api/doc

  1. Repository personnalisé :
// Dans ToolRepository
public function findByFilters(array $filters): array
{
    $qb = $this->createQueryBuilder('t');
    
    if (!empty($filters['department'])) {
        $qb->andWhere('t.ownerDepartment = :dept')
           ->setParameter('dept', $filters['department']);
    }
    
    return $qb->getQuery()->getResult();
}
  1. Gestionnaire d’exceptions :
class ValidationExceptionListener
{
    public function onKernelException(ExceptionEvent $event): void
    {
        $exception = $event->getThrowable();
        
        if ($exception instanceof ValidationException) {
            $response = new JsonResponse([
                'error' => 'Validation failed',
                'details' => $this->formatViolations($exception->getViolations())
            ], 400);
            
            $event->setResponse($response);
        }
    }
}

Évaluation et Perspectives

Profil Technique

Le candidat présente un profil de développeur junior avec des bases techniques correctes. La maîtrise des fondamentaux Symfony et l’approche méthodologique démontrent un potentiel d’évolution intéressant.

Forces à Consolider

  • Architecture respectant les conventions framework
  • Code lisible avec conventions de nommage appropriées
  • Modèle de données cohérent avec la problématique métier
  • Choix technologiques pertinents

Plan d’Actions Prioritaires

  1. Implémentation CRUD complète - Complétion des endpoints manquants
  2. Intégration de la validation - Sécurisation des données entrantes
  3. Refactoring architectural - Création de la couche service
  4. Documentation technique - Production du README et guides

Conclusion Technique

L’évaluation révèle des fondations techniques correctes avec des lacunes typiques d’un profil junior. Les problématiques identifiées sont adressables par un accompagnement technique approprié. Le potentiel d’amélioration est réaliste avec un plan de formation ciblé.

Estimation de progression avec corrections : 75-80% (niveau intermédiaire)

Signature numérique: [SHA256_PLACEHOLDER]

Liens retour