[{"data":1,"prerenderedAt":4810},["ShallowReactive",2],{"series-\u002Ffr\u002Fseries\u002Fempower-and-dynamize-our-vitepress-blog-with-a-laravel-api\u002Fbuilding-a-simple-comment-system-for-user-engagement":3,"series-context-\u002Ffr\u002Fseries\u002Fempower-and-dynamize-our-vitepress-blog-with-a-laravel-api":4598},{"id":4,"title":5,"body":6,"contentId":4585,"date":4586,"description":4587,"extension":4588,"github":4589,"meetTheInstructor":4589,"meta":4590,"navigation":453,"part":347,"path":4591,"rawbody":4592,"robots":4589,"schemaOrg":4589,"seo":4593,"seriesSlug":4594,"sitemap":4595,"stem":4596,"subtitle":4589,"topics":4589,"__hash__":4597},"series\u002Ffr\u002Fseries\u002Fempower-and-dynamize-our-vitepress-blog-with-a-laravel-api\u002Fbuilding-a-simple-comment-system-for-user-engagement.md","Construire un système simple de commentaires Laravel",{"type":7,"value":8,"toc":4576},"minimark",[9,13,16,32,35,43,48,51,54,93,113,123,151,162,165,168,171,185,188,214,233,238,241,250,286,294,314,328,345,355,371,380,383,388,391,395,401,419,422,490,493,553,556,559,585,588,687,690,709,729,735,753,756,828,830,904,907,996,999,1014,1017,1079,1185,1242,1245,1255,1266,1269,1274,1320,1374,1523,1529,1532,1536,1539,1544,1564,1569,1738,1744,1755,1772,1777,1814,1820,1895,1900,1914,1982,1985,1988,2089,2098,2103,2108,2125,2259,2262,2278,2405,2408,2411,2434,2437,2490,2493,2496,2501,2566,2579,2582,2587,2590,2639,2642,2666,2669,2760,2769,2774,2828,2833,2836,2903,2906,2913,2930,3023,3029,3078,3081,3084,3221,3231,3237,3314,3317,3320,3324,3327,3332,3335,3356,3359,3767,3770,3810,3813,3827,3833,3933,3936,3952,3955,4102,4108,4125,4128,4207,4210,4213,4361,4409,4484,4497,4553,4556,4560,4563,4566,4572],[10,11,12],"p",{},"L'authentification GitHub est en place. Nous pouvons maintenant construire la fonctionnalité qu'elle rend possible : les commentaires.",[10,14,15],{},"Avant d'écrire du code, définissons la première version du système de commentaires. Nous voulons prendre en charge les interactions essentielles sans ajouter plus de complexité que nécessaire :",[17,18,19,23,26,29],"ul",{},[20,21,22],"li",{},"Les utilisateurs doivent pouvoir laisser des commentaires sur les articles.",[20,24,25],{},"Les utilisateurs doivent pouvoir modifier ou supprimer leurs commentaires.",[20,27,28],{},"Les réponses aux commentaires ne sont pas prévues.",[20,30,31],{},"La prise en charge du Markdown n'est pas prévue.",[10,33,34],{},"Pour l'instant, nous voulons un système de commentaires volontairement simple.",[36,37,40],"callout",{"color":38,"icon":39},"info","i-ph-info-duotone",[10,41,42],{},"Je souhaite garder le code simple pour deux raisons. D'abord, le processus et les décisions qui le sous-tendent sont plus importants que la quantité de code. Ensuite, des fonctionnalités plus avancées pourront être explorées dans une future série.",[44,45,47],"h2",{"id":46},"construire-le-système-de-commentaires","Construire le système de commentaires",[10,49,50],{},"Maintenant que les exigences sont claires, mettons-les en relation avec les concepts de notre application.",[10,52,53],{},"Un commentaire est un message laissé par un utilisateur sur un article. Dans notre système, le modèle possédera les propriétés suivantes :",[17,55,56,63,69,75,81,87],{},[20,57,58,62],{},[59,60,61],"code",{},"id"," : L'identifiant unique du commentaire.",[20,64,65,68],{},[59,66,67],{},"post_id"," : L'identifiant de l'article auquel le commentaire appartient.",[20,70,71,74],{},[59,72,73],{},"user_id"," : L'identifiant de l'utilisateur qui a laissé le commentaire.",[20,76,77,80],{},[59,78,79],{},"content"," : Le contenu du commentaire.",[20,82,83,86],{},[59,84,85],{},"created_at"," : La date et l'heure de création du commentaire.",[20,88,89,92],{},[59,90,91],{},"updated_at"," : La date et l'heure de sa dernière modification.",[10,94,95,97,98,101,102,105,106,109,110,112],{},[59,96,73],{}," référence la table ",[59,99,100],{},"users",", et le modèle ",[59,103,104],{},"User"," possédera une relation ",[59,107,108],{},"comments",". Qu'en est-il de ",[59,111,67],{}," ?",[10,114,115,116,118,119,122],{},"Pour ",[59,117,67],{},", nous avons besoin d'un modèle ",[59,120,121],{},"Post"," avec les propriétés suivantes :",[17,124,125,130,136,142,147],{},[20,126,127,129],{},[59,128,61],{}," : L'identifiant unique de l'article.",[20,131,132,135],{},[59,133,134],{},"meta_id"," : L'identifiant unique provenant du front-end.",[20,137,138,141],{},[59,139,140],{},"title"," : Le titre de l'article.",[20,143,144,146],{},[59,145,85],{}," : La date et l'heure de création de l'article.",[20,148,149,92],{},[59,150,91],{},[10,152,153,154,105,156,158,159,161],{},"Le modèle ",[59,155,121],{},[59,157,108],{},", ce qui nous permettra d'associer plusieurs commentaires à chaque article. Nous parlerons de ",[59,160,134],{}," dans l'article suivant, vous pouvez donc ignorer son rôle pour le moment.",[10,163,164],{},"Les relations ressembleront à ceci :",[10,166,167],{},"Une fois les modèles et les relations définis, nous pouvons concevoir l'API qui permettra de récupérer, créer, modifier et supprimer les commentaires.",[10,169,170],{},"Commençons par lister les endpoints nécessaires :",[17,172,173,176,179,182],{},[20,174,175],{},"Lister tous les commentaires d'un article, quelle que soit leur origine",[20,177,178],{},"Créer un commentaire avec un utilisateur authentifié",[20,180,181],{},"Modifier un commentaire avec l'utilisateur qui l'a créé",[20,183,184],{},"Supprimer un commentaire avec l'utilisateur qui l'a créé",[10,186,187],{},"Associons ensuite les endpoints aux routes :",[17,189,190,196,202,208],{},[20,191,192,195],{},[59,193,194],{},"GET    \u002Fposts\u002F{post}\u002Fcomments"," : Lister tous les commentaires d'un article",[20,197,198,201],{},[59,199,200],{},"POST   \u002Fposts\u002F{post}\u002Fcomments"," : Créer un commentaire",[20,203,204,207],{},[59,205,206],{},"PUT    \u002Fcomments\u002F{comment}"," : Modifier un commentaire",[20,209,210,213],{},[59,211,212],{},"DELETE \u002Fcomments\u002F{comment}"," : Supprimer un commentaire",[10,215,216,217,220,221,224,225,232],{},"L'association est simple. Pourquoi utiliser ",[59,218,219],{},"\u002Fcomments\u002F{comment}"," plutôt que ",[59,222,223],{},"\u002Fposts\u002F{post}\u002Fcomments\u002F{comment}"," pour les deux dernières routes ? L'identifiant d'un commentaire est unique, il permet donc de l'identifier sans répéter celui de l'article. Dans Laravel, on appelle cela le ",[226,227,231],"a",{"href":228,"rel":229},"https:\u002F\u002Flaravel.com\u002Fdocs\u002F12.x\u002Fcontrollers#shallow-nesting",[230],"nofollow","shallow nesting",", ou imbrication superficielle.",[234,235,237],"h3",{"id":236},"résumé-avant-décrire-le-code","Résumé avant d'écrire le code",[10,239,240],{},"Avant de commencer à coder, résumons les étapes d'implémentation :",[242,243,244],"ol",{},[20,245,246,247,249],{},"Créer un modèle ",[59,248,121],{}," avec sa migration.",[251,252,258],"pre",{"className":253,"code":254,"filename":255,"language":256,"meta":257,"style":257},"language-bash shiki shiki-themes github-light github-light github-dark","php artisan make:model Post -m -f\n","terminal","bash","",[59,259,260],{"__ignoreMap":257},[261,262,265,269,273,276,279,283],"span",{"class":263,"line":264},"line",1,[261,266,268],{"class":267},"snPdu","php",[261,270,272],{"class":271},"sIIMD"," artisan",[261,274,275],{"class":271}," make:model",[261,277,278],{"class":271}," Post",[261,280,282],{"class":281},"sBjJW"," -m",[261,284,285],{"class":281}," -f\n",[242,287,289],{"start":288},2,[20,290,246,291,249],{},[59,292,293],{},"Comment",[251,295,297],{"className":253,"code":296,"filename":255,"language":256,"meta":257,"style":257},"php artisan make:model Comment -m -f\n",[59,298,299],{"__ignoreMap":257},[261,300,301,303,305,307,310,312],{"class":263,"line":264},[261,302,268],{"class":267},[261,304,272],{"class":271},[261,306,275],{"class":271},[261,308,309],{"class":271}," Comment",[261,311,282],{"class":281},[261,313,285],{"class":281},[242,315,317],{"start":316},3,[20,318,319,320,323,324,327],{},"Créer un ",[59,321,322],{},"CommentController"," dans ",[59,325,326],{},"app\u002FHttp\u002FApi",".",[251,329,331],{"className":253,"code":330,"filename":255,"language":256,"meta":257,"style":257},"php artisan make:controller Api\u002FCommentController\n",[59,332,333],{"__ignoreMap":257},[261,334,335,337,339,342],{"class":263,"line":264},[261,336,268],{"class":267},[261,338,272],{"class":271},[261,340,341],{"class":271}," make:controller",[261,343,344],{"class":271}," Api\u002FCommentController\n",[242,346,348],{"start":347},4,[20,349,319,350,323,353,327],{},[59,351,352],{},"PostCommentController",[59,354,326],{},[251,356,358],{"className":253,"code":357,"filename":255,"language":256,"meta":257,"style":257},"php artisan make:controller Api\u002FPostCommentController\n",[59,359,360],{"__ignoreMap":257},[261,361,362,364,366,368],{"class":263,"line":264},[261,363,268],{"class":267},[261,365,272],{"class":271},[261,367,341],{"class":271},[261,369,370],{"class":271}," Api\u002FPostCommentController\n",[242,372,374],{"start":373},5,[20,375,376,377,327],{},"Ajouter les routes à ",[59,378,379],{},"routes\u002Fapi.php",[10,381,382],{},"Nous ajouterons les tests au fur et à mesure.",[36,384,385],{"color":38,"icon":39},[10,386,387],{},"Je n'expliquerai pas chaque test en détail. Je me concentrerai sur les plus importants.",[10,389,390],{},"Prêt ? C'est parti !",[44,392,394],{"id":393},"consulter-et-créer-des-commentaires","Consulter et créer des commentaires",[10,396,397,398,400],{},"Créez le modèle ",[59,399,121],{}," avec Artisan :",[251,402,403],{"className":253,"code":254,"filename":255,"language":256,"meta":257,"style":257},[59,404,405],{"__ignoreMap":257},[261,406,407,409,411,413,415,417],{"class":263,"line":264},[261,408,268],{"class":267},[261,410,272],{"class":271},[261,412,275],{"class":271},[261,414,278],{"class":271},[261,416,282],{"class":281},[261,418,285],{"class":281},[10,420,421],{},"Ouvrons maintenant le fichier de migration et ajoutons le code suivant :",[251,423,427],{"className":424,"code":425,"filename":426,"language":268,"meta":257,"style":257},"language-php shiki shiki-themes github-light github-light github-dark","return new class extends Migration\n{\n    Schema::create('posts', function (Blueprint $table) {\n        $table->id();\n\n        $table->string('title'); \u002F\u002F [!code ++]\n        $table->unsignedInteger('meta_id')->unique(); \u002F\u002F [!code ++]\n\n        $table->timestamps();\n    });\n};\n","database\u002Fmigrations\u002F2025_03_02_121249_create_posts_table.php",[59,428,429,434,439,444,449,455,461,467,472,478,484],{"__ignoreMap":257},[261,430,431],{"class":263,"line":264},[261,432,433],{},"return new class extends Migration\n",[261,435,436],{"class":263,"line":288},[261,437,438],{},"{\n",[261,440,441],{"class":263,"line":316},[261,442,443],{},"    Schema::create('posts', function (Blueprint $table) {\n",[261,445,446],{"class":263,"line":347},[261,447,448],{},"        $table->id();\n",[261,450,451],{"class":263,"line":373},[261,452,454],{"emptyLinePlaceholder":453},true,"\n",[261,456,458],{"class":263,"line":457},6,[261,459,460],{},"        $table->string('title'); \u002F\u002F [!code ++]\n",[261,462,464],{"class":263,"line":463},7,[261,465,466],{},"        $table->unsignedInteger('meta_id')->unique(); \u002F\u002F [!code ++]\n",[261,468,470],{"class":263,"line":469},8,[261,471,454],{"emptyLinePlaceholder":453},[261,473,475],{"class":263,"line":474},9,[261,476,477],{},"        $table->timestamps();\n",[261,479,481],{"class":263,"line":480},10,[261,482,483],{},"    });\n",[261,485,487],{"class":263,"line":486},11,[261,488,489],{},"};\n",[10,491,492],{},"Mettez à jour la factory pour qu'elle corresponde à la migration :",[251,494,498],{"className":495,"code":496,"filename":497,"language":268,"meta":257,"style":257},"language-php shiki shiki-themes github-light github-light github-dark has-diff","class PostFactory extends Factory\n{\n    public function definition(): array\n    {\n        return [\n            'title' => fake()->sentence(), \u002F\u002F [!code ++]\n            'meta_id' => fake()->unique()->numberBetween(1, 1000), \u002F\u002F [!code ++]\n        ];\n    }\n}\n","database\u002Ffactories\u002FPostFactory.php",[59,499,500,505,509,514,519,524,532,538,543,548],{"__ignoreMap":257},[261,501,502],{"class":263,"line":264},[261,503,504],{},"class PostFactory extends Factory\n",[261,506,507],{"class":263,"line":288},[261,508,438],{},[261,510,511],{"class":263,"line":316},[261,512,513],{},"    public function definition(): array\n",[261,515,516],{"class":263,"line":347},[261,517,518],{},"    {\n",[261,520,521],{"class":263,"line":373},[261,522,523],{},"        return [\n",[261,525,529],{"class":526,"line":457},[263,527,528],"diff","add",[261,530,531],{},"            'title' => fake()->sentence(),",[261,533,535],{"class":534,"line":463},[263,527,528],[261,536,537],{},"            'meta_id' => fake()->unique()->numberBetween(1, 1000),",[261,539,540],{"class":263,"line":469},[261,541,542],{},"        ];\n",[261,544,545],{"class":263,"line":474},[261,546,547],{},"    }\n",[261,549,550],{"class":263,"line":480},[261,551,552],{},"}\n",[10,554,555],{},"Ajoutons un test pour vérifier que le modèle possède la forme attendue.",[10,557,558],{},"Commençons par créer le fichier de test :",[251,560,562],{"className":253,"code":561,"filename":255,"language":256,"meta":257,"style":257},"mkdir -p tests\u002FUnit\u002FModels && touch tests\u002FUnit\u002FModels\u002FPostTest.php\n",[59,563,564],{"__ignoreMap":257},[261,565,566,569,572,575,579,582],{"class":263,"line":264},[261,567,568],{"class":267},"mkdir",[261,570,571],{"class":281}," -p",[261,573,574],{"class":271}," tests\u002FUnit\u002FModels",[261,576,578],{"class":577},"sxrX7"," && ",[261,580,581],{"class":267},"touch",[261,583,584],{"class":271}," tests\u002FUnit\u002FModels\u002FPostTest.php\n",[10,586,587],{},"Puis ajoutons le code suivant :",[251,589,592],{"className":424,"code":590,"filename":591,"language":268,"meta":257,"style":257},"\u003C?php\n\ndeclare(strict_types=1);\n\nuse App\\Models\\Post;\n\ntest('to array', function () {\n    $post = Post::factory()->create()->fresh();\n\n    expect(array_keys($post->toArray()))\n        ->toEqual([\n            'id',\n            'title',\n            'meta_id',\n            'created_at',\n            'updated_at',\n        ]);\n});\n","tests\u002FUnit\u002FModels\u002FPostTest.php",[59,593,594,599,603,608,612,617,621,626,631,635,640,645,651,657,663,669,675,681],{"__ignoreMap":257},[261,595,596],{"class":263,"line":264},[261,597,598],{},"\u003C?php\n",[261,600,601],{"class":263,"line":288},[261,602,454],{"emptyLinePlaceholder":453},[261,604,605],{"class":263,"line":316},[261,606,607],{},"declare(strict_types=1);\n",[261,609,610],{"class":263,"line":347},[261,611,454],{"emptyLinePlaceholder":453},[261,613,614],{"class":263,"line":373},[261,615,616],{},"use App\\Models\\Post;\n",[261,618,619],{"class":263,"line":457},[261,620,454],{"emptyLinePlaceholder":453},[261,622,623],{"class":263,"line":463},[261,624,625],{},"test('to array', function () {\n",[261,627,628],{"class":263,"line":469},[261,629,630],{},"    $post = Post::factory()->create()->fresh();\n",[261,632,633],{"class":263,"line":474},[261,634,454],{"emptyLinePlaceholder":453},[261,636,637],{"class":263,"line":480},[261,638,639],{},"    expect(array_keys($post->toArray()))\n",[261,641,642],{"class":263,"line":486},[261,643,644],{},"        ->toEqual([\n",[261,646,648],{"class":263,"line":647},12,[261,649,650],{},"            'id',\n",[261,652,654],{"class":263,"line":653},13,[261,655,656],{},"            'title',\n",[261,658,660],{"class":263,"line":659},14,[261,661,662],{},"            'meta_id',\n",[261,664,666],{"class":263,"line":665},15,[261,667,668],{},"            'created_at',\n",[261,670,672],{"class":263,"line":671},16,[261,673,674],{},"            'updated_at',\n",[261,676,678],{"class":263,"line":677},17,[261,679,680],{},"        ]);\n",[261,682,684],{"class":263,"line":683},18,[261,685,686],{},"});\n",[10,688,689],{},"Ce test minimal vérifie les propriétés persistées du modèle. Il peut détecter la suppression ou l'ajout accidentel d'une colonne dans une migration. Nous ajouterons un test similaire pour chaque modèle créé.",[10,691,692,693,696,697,700,701,704,705,708],{},"Pour vérifier que le test fonctionne, le dossier ",[59,694,695],{},"tests\u002FUnit"," doit avoir accès à une base de données fonctionnelle. Ajoutons ",[59,698,699],{},"Unit"," à la méthode ",[59,702,703],{},"in"," du fichier ",[59,706,707],{},"tests\u002FPest.php"," :",[251,710,712],{"className":424,"code":711,"filename":707,"language":268,"meta":257,"style":257},"pest()->extend(Tests\\TestCase::class)\n    ->use(Illuminate\\Foundation\\Testing\\RefreshDatabase::class)\n    ->in('Http', 'Unit');\n",[59,713,714,719,724],{"__ignoreMap":257},[261,715,716],{"class":263,"line":264},[261,717,718],{},"pest()->extend(Tests\\TestCase::class)\n",[261,720,721],{"class":263,"line":288},[261,722,723],{},"    ->use(Illuminate\\Foundation\\Testing\\RefreshDatabase::class)\n",[261,725,726],{"class":263,"line":316},[261,727,728],{},"    ->in('Http', 'Unit');\n",[10,730,731,732,734],{},"Créons le modèle ",[59,733,293],{}," de la même manière :",[251,736,737],{"className":253,"code":296,"filename":255,"language":256,"meta":257,"style":257},[59,738,739],{"__ignoreMap":257},[261,740,741,743,745,747,749,751],{"class":263,"line":264},[261,742,268],{"class":267},[261,744,272],{"class":271},[261,746,275],{"class":271},[261,748,309],{"class":271},[261,750,282],{"class":281},[261,752,285],{"class":281},[10,754,755],{},"Mettez à jour sa migration :",[251,757,760],{"className":424,"code":758,"filename":759,"language":268,"meta":257,"style":257},"use App\\Models\\Post; \u002F\u002F [!code ++]\nuse App\\Models\\User; \u002F\u002F [!code ++]\n\nreturn new class extends Migration\n{\n    Schema::create('comments', function (Blueprint $table) {\n        $table->id();\n\n        $table->foreignIdFor(Post::class)->constrained()->cascadeOnDelete(); \u002F\u002F [!code ++]\n        $table->foreignIdFor(User::class)->constrained()->cascadeOnDelete(); \u002F\u002F [!code ++]\n        $table->text('content'); \u002F\u002F [!code ++]\n\n        $table->timestamps();\n    });\n};\n","database\u002Fmigrations\u002F2025_03_02_121249_create_comments_table.php",[59,761,762,767,772,776,780,784,789,793,797,802,807,812,816,820,824],{"__ignoreMap":257},[261,763,764],{"class":263,"line":264},[261,765,766],{},"use App\\Models\\Post; \u002F\u002F [!code ++]\n",[261,768,769],{"class":263,"line":288},[261,770,771],{},"use App\\Models\\User; \u002F\u002F [!code ++]\n",[261,773,774],{"class":263,"line":316},[261,775,454],{"emptyLinePlaceholder":453},[261,777,778],{"class":263,"line":347},[261,779,433],{},[261,781,782],{"class":263,"line":373},[261,783,438],{},[261,785,786],{"class":263,"line":457},[261,787,788],{},"    Schema::create('comments', function (Blueprint $table) {\n",[261,790,791],{"class":263,"line":463},[261,792,448],{},[261,794,795],{"class":263,"line":469},[261,796,454],{"emptyLinePlaceholder":453},[261,798,799],{"class":263,"line":474},[261,800,801],{},"        $table->foreignIdFor(Post::class)->constrained()->cascadeOnDelete(); \u002F\u002F [!code ++]\n",[261,803,804],{"class":263,"line":480},[261,805,806],{},"        $table->foreignIdFor(User::class)->constrained()->cascadeOnDelete(); \u002F\u002F [!code ++]\n",[261,808,809],{"class":263,"line":486},[261,810,811],{},"        $table->text('content'); \u002F\u002F [!code ++]\n",[261,813,814],{"class":263,"line":647},[261,815,454],{"emptyLinePlaceholder":453},[261,817,818],{"class":263,"line":653},[261,819,477],{},[261,821,822],{"class":263,"line":659},[261,823,483],{},[261,825,826],{"class":263,"line":665},[261,827,489],{},[10,829,492],{},[251,831,834],{"className":495,"code":832,"filename":833,"language":268,"meta":257,"style":257},"use App\\Models\\Post; \u002F\u002F [!code ++]\nuse App\\Models\\User; \u002F\u002F [!code ++]\n\n\u002F\u002F ...\nclass CommentFactory extends Factory\n{\n    public function definition(): array\n    {\n        return [\n            'post_id' => Post::factory(), \u002F\u002F [!code ++]\n            'user_id' => User::factory(), \u002F\u002F [!code ++]\n            'content' => fake()->paragraph(), \u002F\u002F [!code ++]\n        ];\n    }\n}\n","database\u002Ffactories\u002FCommentFactory.php",[59,835,836,840,844,848,853,858,862,866,870,874,880,886,892,896,900],{"__ignoreMap":257},[261,837,838],{"class":263,"line":264},[261,839,766],{},[261,841,842],{"class":263,"line":288},[261,843,771],{},[261,845,846],{"class":263,"line":316},[261,847,454],{"emptyLinePlaceholder":453},[261,849,850],{"class":263,"line":347},[261,851,852],{},"\u002F\u002F ...\n",[261,854,855],{"class":263,"line":373},[261,856,857],{},"class CommentFactory extends Factory\n",[261,859,860],{"class":263,"line":457},[261,861,438],{},[261,863,864],{"class":263,"line":463},[261,865,513],{},[261,867,868],{"class":263,"line":469},[261,869,518],{},[261,871,872],{"class":263,"line":474},[261,873,523],{},[261,875,877],{"class":876,"line":480},[263,527,528],[261,878,879],{},"            'post_id' => Post::factory(),",[261,881,883],{"class":882,"line":486},[263,527,528],[261,884,885],{},"            'user_id' => User::factory(),",[261,887,889],{"class":888,"line":647},[263,527,528],[261,890,891],{},"            'content' => fake()->paragraph(),",[261,893,894],{"class":263,"line":653},[261,895,542],{},[261,897,898],{"class":263,"line":659},[261,899,547],{},[261,901,902],{"class":263,"line":665},[261,903,552],{},[10,905,906],{},"Ajoutez le test correspondant :",[251,908,911],{"className":424,"code":909,"filename":910,"language":268,"meta":257,"style":257},"\u003C?php\n\ndeclare(strict_types=1);\n\nuse App\\Models\\Comment;\n\ntest('to array', function () {\n    $comment = Comment::factory()->create()->fresh();\n\n    expect(array_keys($comment->toArray()))\n        ->toEqual([\n            'id',\n            'post_id',\n            'user_id',\n            'content',\n            'created_at',\n            'updated_at',\n        ]);\n});\n","tests\u002FUnit\u002FModels\u002FCommentTest.php",[59,912,913,917,921,925,929,934,938,942,947,951,956,960,964,969,974,979,983,987,991],{"__ignoreMap":257},[261,914,915],{"class":263,"line":264},[261,916,598],{},[261,918,919],{"class":263,"line":288},[261,920,454],{"emptyLinePlaceholder":453},[261,922,923],{"class":263,"line":316},[261,924,607],{},[261,926,927],{"class":263,"line":347},[261,928,454],{"emptyLinePlaceholder":453},[261,930,931],{"class":263,"line":373},[261,932,933],{},"use App\\Models\\Comment;\n",[261,935,936],{"class":263,"line":457},[261,937,454],{"emptyLinePlaceholder":453},[261,939,940],{"class":263,"line":463},[261,941,625],{},[261,943,944],{"class":263,"line":469},[261,945,946],{},"    $comment = Comment::factory()->create()->fresh();\n",[261,948,949],{"class":263,"line":474},[261,950,454],{"emptyLinePlaceholder":453},[261,952,953],{"class":263,"line":480},[261,954,955],{},"    expect(array_keys($comment->toArray()))\n",[261,957,958],{"class":263,"line":486},[261,959,644],{},[261,961,962],{"class":263,"line":647},[261,963,650],{},[261,965,966],{"class":263,"line":653},[261,967,968],{},"            'post_id',\n",[261,970,971],{"class":263,"line":659},[261,972,973],{},"            'user_id',\n",[261,975,976],{"class":263,"line":665},[261,977,978],{},"            'content',\n",[261,980,981],{"class":263,"line":671},[261,982,668],{},[261,984,985],{"class":263,"line":677},[261,986,674],{},[261,988,989],{"class":263,"line":683},[261,990,680],{},[261,992,994],{"class":263,"line":993},19,[261,995,686],{},[10,997,998],{},"Ajoutons maintenant les relations. Un article possède plusieurs commentaires, un commentaire appartient à un article, un commentaire appartient à un utilisateur et un utilisateur possède plusieurs commentaires.",[36,1000,1001],{"color":38,"icon":39},[10,1002,1003,1004,220,1007,1010,1011,1013],{},"Nous utilisons ",[59,1005,1006],{},"belongs to",[59,1008,1009],{},"has one",", car un commentaire est un enfant d'un article et ne peut pas exister sans lui. Une relation ",[59,1012,1009],{}," décrit le modèle parent qui possède un enfant unique, comme un utilisateur qui possède un profil alors que le profil appartient à l'utilisateur.",[10,1015,1016],{},"Voici ces relations :",[251,1018,1021],{"className":424,"code":1019,"filename":1020,"language":268,"meta":257,"style":257},"class Post extends Model\n{\n    \u002F**\n     * Get all of the comments for the Post\n     *\n     * @return HasMany\u003CComment, covariant Post>\n     *\u002F\n    public function comments(): HasMany\n    {\n        return $this->hasMany(Comment::class);\n    }\n}\n","app\u002FModels\u002FPost.php",[59,1022,1023,1028,1032,1037,1042,1047,1052,1057,1062,1066,1071,1075],{"__ignoreMap":257},[261,1024,1025],{"class":263,"line":264},[261,1026,1027],{},"class Post extends Model\n",[261,1029,1030],{"class":263,"line":288},[261,1031,438],{},[261,1033,1034],{"class":263,"line":316},[261,1035,1036],{},"    \u002F**\n",[261,1038,1039],{"class":263,"line":347},[261,1040,1041],{},"     * Get all of the comments for the Post\n",[261,1043,1044],{"class":263,"line":373},[261,1045,1046],{},"     *\n",[261,1048,1049],{"class":263,"line":457},[261,1050,1051],{},"     * @return HasMany\u003CComment, covariant Post>\n",[261,1053,1054],{"class":263,"line":463},[261,1055,1056],{},"     *\u002F\n",[261,1058,1059],{"class":263,"line":469},[261,1060,1061],{},"    public function comments(): HasMany\n",[261,1063,1064],{"class":263,"line":474},[261,1065,518],{},[261,1067,1068],{"class":263,"line":480},[261,1069,1070],{},"        return $this->hasMany(Comment::class);\n",[261,1072,1073],{"class":263,"line":486},[261,1074,547],{},[261,1076,1077],{"class":263,"line":647},[261,1078,552],{},[251,1080,1083],{"className":424,"code":1081,"filename":1082,"language":268,"meta":257,"style":257},"class Comment extends Model\n{\n    \u002F**\n     * Get the post that owns the comment.\n     *\n     * @return BelongsTo\u003CPost, covariant Comment>\n     *\u002F\n    public function post(): BelongsTo\n    {\n        return $this->belongsTo(Post::class);\n    }\n\n    \u002F**\n     * Get the user that owns the comment.\n     *\n     * @return BelongsTo\u003CUser, covariant Comment>\n     *\u002F\n    public function user(): BelongsTo\n    {\n        return $this->belongsTo(User::class);\n    }\n}\n","app\u002FModels\u002FComment.php",[59,1084,1085,1090,1094,1098,1103,1107,1112,1116,1121,1125,1130,1134,1138,1142,1147,1151,1156,1160,1165,1169,1175,1180],{"__ignoreMap":257},[261,1086,1087],{"class":263,"line":264},[261,1088,1089],{},"class Comment extends Model\n",[261,1091,1092],{"class":263,"line":288},[261,1093,438],{},[261,1095,1096],{"class":263,"line":316},[261,1097,1036],{},[261,1099,1100],{"class":263,"line":347},[261,1101,1102],{},"     * Get the post that owns the comment.\n",[261,1104,1105],{"class":263,"line":373},[261,1106,1046],{},[261,1108,1109],{"class":263,"line":457},[261,1110,1111],{},"     * @return BelongsTo\u003CPost, covariant Comment>\n",[261,1113,1114],{"class":263,"line":463},[261,1115,1056],{},[261,1117,1118],{"class":263,"line":469},[261,1119,1120],{},"    public function post(): BelongsTo\n",[261,1122,1123],{"class":263,"line":474},[261,1124,518],{},[261,1126,1127],{"class":263,"line":480},[261,1128,1129],{},"        return $this->belongsTo(Post::class);\n",[261,1131,1132],{"class":263,"line":486},[261,1133,547],{},[261,1135,1136],{"class":263,"line":647},[261,1137,454],{"emptyLinePlaceholder":453},[261,1139,1140],{"class":263,"line":653},[261,1141,1036],{},[261,1143,1144],{"class":263,"line":659},[261,1145,1146],{},"     * Get the user that owns the comment.\n",[261,1148,1149],{"class":263,"line":665},[261,1150,1046],{},[261,1152,1153],{"class":263,"line":671},[261,1154,1155],{},"     * @return BelongsTo\u003CUser, covariant Comment>\n",[261,1157,1158],{"class":263,"line":677},[261,1159,1056],{},[261,1161,1162],{"class":263,"line":683},[261,1163,1164],{},"    public function user(): BelongsTo\n",[261,1166,1167],{"class":263,"line":993},[261,1168,518],{},[261,1170,1172],{"class":263,"line":1171},20,[261,1173,1174],{},"        return $this->belongsTo(User::class);\n",[261,1176,1178],{"class":263,"line":1177},21,[261,1179,547],{},[261,1181,1183],{"class":263,"line":1182},22,[261,1184,552],{},[251,1186,1189],{"className":424,"code":1187,"filename":1188,"language":268,"meta":257,"style":257},"class User extends Authenticatable\n{\n    \u002F**\n     * Get comments that belong to the user.\n     *\n     * @return HasMany\u003CComment, covariant User>\n     *\u002F\n    public function comments(): HasMany\n    {\n        return $this->hasMany(Comment::class);\n    }\n}\n","app\u002FModels\u002FUser.php",[59,1190,1191,1196,1200,1204,1209,1213,1218,1222,1226,1230,1234,1238],{"__ignoreMap":257},[261,1192,1193],{"class":263,"line":264},[261,1194,1195],{},"class User extends Authenticatable\n",[261,1197,1198],{"class":263,"line":288},[261,1199,438],{},[261,1201,1202],{"class":263,"line":316},[261,1203,1036],{},[261,1205,1206],{"class":263,"line":347},[261,1207,1208],{},"     * Get comments that belong to the user.\n",[261,1210,1211],{"class":263,"line":373},[261,1212,1046],{},[261,1214,1215],{"class":263,"line":457},[261,1216,1217],{},"     * @return HasMany\u003CComment, covariant User>\n",[261,1219,1220],{"class":263,"line":463},[261,1221,1056],{},[261,1223,1224],{"class":263,"line":469},[261,1225,1061],{},[261,1227,1228],{"class":263,"line":474},[261,1229,518],{},[261,1231,1232],{"class":263,"line":480},[261,1233,1070],{},[261,1235,1236],{"class":263,"line":486},[261,1237,547],{},[261,1239,1240],{"class":263,"line":647},[261,1241,552],{},[10,1243,1244],{},"Ces relations simplifient les requêtes Eloquent. Pour récupérer tous les commentaires d'un article, nous pouvons écrire :",[251,1246,1249],{"className":424,"code":1247,"filename":1248,"language":268,"meta":257,"style":257},"Post::find(1)->comments;\n","Exemple",[59,1250,1251],{"__ignoreMap":257},[261,1252,1253],{"class":263,"line":264},[261,1254,1247],{},[10,1256,1257,1258,1261,1262,1265],{},"Elles facilitent également l'utilisation de méthodes de factory comme ",[59,1259,1260],{},"has"," et ",[59,1263,1264],{},"for"," pour créer des modèles liés.",[10,1267,1268],{},"Ajoutons des tests de relations pour vérifier que les modèles sont reliés comme prévu.",[36,1270,1271],{"color":38,"icon":39},[10,1272,1273],{},"Lorsque je travaille sur des modèles, j'écris souvent les tests après la première implémentation, car la conception peut évoluer rapidement. Écrire le modèle m'aide à clarifier ce que les tests doivent vérifier.",[251,1275,1277],{"className":424,"code":1276,"filename":591,"language":268,"meta":257,"style":257},"use App\\Models\\Comment;\n\ntest('relations', function () {\n    $post = Post::factory()\n        ->hasComments(1)\n        ->create();\n\n    expect($post->comments)->each->toBeInstanceOf(Comment::class);\n});\n",[59,1278,1279,1283,1287,1292,1297,1302,1307,1311,1316],{"__ignoreMap":257},[261,1280,1281],{"class":263,"line":264},[261,1282,933],{},[261,1284,1285],{"class":263,"line":288},[261,1286,454],{"emptyLinePlaceholder":453},[261,1288,1289],{"class":263,"line":316},[261,1290,1291],{},"test('relations', function () {\n",[261,1293,1294],{"class":263,"line":347},[261,1295,1296],{},"    $post = Post::factory()\n",[261,1298,1299],{"class":263,"line":373},[261,1300,1301],{},"        ->hasComments(1)\n",[261,1303,1304],{"class":263,"line":457},[261,1305,1306],{},"        ->create();\n",[261,1308,1309],{"class":263,"line":463},[261,1310,454],{"emptyLinePlaceholder":453},[261,1312,1313],{"class":263,"line":469},[261,1314,1315],{},"    expect($post->comments)->each->toBeInstanceOf(Comment::class);\n",[261,1317,1318],{"class":263,"line":474},[261,1319,686],{},[251,1321,1323],{"className":424,"code":1322,"filename":910,"language":268,"meta":257,"style":257},"use App\\Models\\Post;\nuse App\\Models\\User;\n\ntest('relations', function () {\n    $comment = Comment::factory()\n        ->forPost()\n        ->create();\n\n    expect($comment->post)->toBeInstanceOf(Post::class)\n        ->and($comment->user)->toBeInstanceOf(User::class);\n});\n",[59,1324,1325,1329,1334,1338,1342,1347,1352,1356,1360,1365,1370],{"__ignoreMap":257},[261,1326,1327],{"class":263,"line":264},[261,1328,616],{},[261,1330,1331],{"class":263,"line":288},[261,1332,1333],{},"use App\\Models\\User;\n",[261,1335,1336],{"class":263,"line":316},[261,1337,454],{"emptyLinePlaceholder":453},[261,1339,1340],{"class":263,"line":347},[261,1341,1291],{},[261,1343,1344],{"class":263,"line":373},[261,1345,1346],{},"    $comment = Comment::factory()\n",[261,1348,1349],{"class":263,"line":457},[261,1350,1351],{},"        ->forPost()\n",[261,1353,1354],{"class":263,"line":463},[261,1355,1306],{},[261,1357,1358],{"class":263,"line":469},[261,1359,454],{"emptyLinePlaceholder":453},[261,1361,1362],{"class":263,"line":474},[261,1363,1364],{},"    expect($comment->post)->toBeInstanceOf(Post::class)\n",[261,1366,1367],{"class":263,"line":480},[261,1368,1369],{},"        ->and($comment->user)->toBeInstanceOf(User::class);\n",[261,1371,1372],{"class":263,"line":486},[261,1373,686],{},[251,1375,1378],{"className":424,"code":1376,"filename":1377,"language":268,"meta":257,"style":257},"\u003C?php\n\ndeclare(strict_types=1);\n\nuse App\\Models\\Comment;\nuse App\\Models\\User;\n\ntest('to array', function () {\n    $user = User::factory()->create()->fresh();\n\n    expect(array_keys($user->toArray()))\n        ->toEqual([\n            'id',\n            'name',\n            'username',\n            'email',\n            'email_verified_at',\n            'github_id',\n            'avatar',\n            'created_at',\n            'updated_at',\n        ]);\n});\n\ntest('relations', function () {\n    $user = User::factory()\n        ->hasComments(1)\n        ->create();\n\n    expect($user->comments)->each->toBeInstanceOf(Comment::class);\n});\n","tests\u002FUnit\u002FModels\u002FUserTest.php",[59,1379,1380,1384,1388,1392,1396,1400,1404,1408,1412,1417,1421,1426,1430,1434,1439,1444,1449,1454,1459,1464,1468,1472,1476,1481,1486,1491,1497,1502,1507,1512,1518],{"__ignoreMap":257},[261,1381,1382],{"class":263,"line":264},[261,1383,598],{},[261,1385,1386],{"class":263,"line":288},[261,1387,454],{"emptyLinePlaceholder":453},[261,1389,1390],{"class":263,"line":316},[261,1391,607],{},[261,1393,1394],{"class":263,"line":347},[261,1395,454],{"emptyLinePlaceholder":453},[261,1397,1398],{"class":263,"line":373},[261,1399,933],{},[261,1401,1402],{"class":263,"line":457},[261,1403,1333],{},[261,1405,1406],{"class":263,"line":463},[261,1407,454],{"emptyLinePlaceholder":453},[261,1409,1410],{"class":263,"line":469},[261,1411,625],{},[261,1413,1414],{"class":263,"line":474},[261,1415,1416],{},"    $user = User::factory()->create()->fresh();\n",[261,1418,1419],{"class":263,"line":480},[261,1420,454],{"emptyLinePlaceholder":453},[261,1422,1423],{"class":263,"line":486},[261,1424,1425],{},"    expect(array_keys($user->toArray()))\n",[261,1427,1428],{"class":263,"line":647},[261,1429,644],{},[261,1431,1432],{"class":263,"line":653},[261,1433,650],{},[261,1435,1436],{"class":263,"line":659},[261,1437,1438],{},"            'name',\n",[261,1440,1441],{"class":263,"line":665},[261,1442,1443],{},"            'username',\n",[261,1445,1446],{"class":263,"line":671},[261,1447,1448],{},"            'email',\n",[261,1450,1451],{"class":263,"line":677},[261,1452,1453],{},"            'email_verified_at',\n",[261,1455,1456],{"class":263,"line":683},[261,1457,1458],{},"            'github_id',\n",[261,1460,1461],{"class":263,"line":993},[261,1462,1463],{},"            'avatar',\n",[261,1465,1466],{"class":263,"line":1171},[261,1467,668],{},[261,1469,1470],{"class":263,"line":1177},[261,1471,674],{},[261,1473,1474],{"class":263,"line":1182},[261,1475,680],{},[261,1477,1479],{"class":263,"line":1478},23,[261,1480,686],{},[261,1482,1484],{"class":263,"line":1483},24,[261,1485,454],{"emptyLinePlaceholder":453},[261,1487,1489],{"class":263,"line":1488},25,[261,1490,1291],{},[261,1492,1494],{"class":263,"line":1493},26,[261,1495,1496],{},"    $user = User::factory()\n",[261,1498,1500],{"class":263,"line":1499},27,[261,1501,1301],{},[261,1503,1505],{"class":263,"line":1504},28,[261,1506,1306],{},[261,1508,1510],{"class":263,"line":1509},29,[261,1511,454],{"emptyLinePlaceholder":453},[261,1513,1515],{"class":263,"line":1514},30,[261,1516,1517],{},"    expect($user->comments)->each->toBeInstanceOf(Comment::class);\n",[261,1519,1521],{"class":263,"line":1520},31,[261,1522,686],{},[10,1524,1525,1526,1528],{},"Nous n'avions pas encore ajouté de tests pour ",[59,1527,104],{},", c'est donc une bonne occasion d'ajouter également son test de forme.",[10,1530,1531],{},"Le fonctionnement reste cohérent et Laravel rend chaque étape simple.",[44,1533,1535],{"id":1534},"créer-les-contrôleurs","Créer les contrôleurs",[10,1537,1538],{},"Maintenant que les modèles sont prêts, nous pouvons créer les contrôleurs.",[10,1540,1541,1543],{},[59,1542,352],{}," possédera deux méthodes :",[17,1545,1546,1555],{},[20,1547,1548,1551,1552,327],{},[59,1549,1550],{},"index"," : Liste tous les commentaires d'un article avec ",[59,1553,1554],{},"GET \u002Fposts\u002F{post}\u002Fcomments",[20,1556,1557,1560,1561,327],{},[59,1558,1559],{},"store"," : Crée un commentaire avec ",[59,1562,1563],{},"POST \u002Fposts\u002F{post}\u002Fcomments",[10,1565,1566,1567,708],{},"Comme dans l'article précédent, commençons par écrire un test pour la méthode ",[59,1568,1550],{},[251,1570,1573],{"className":424,"code":1571,"filename":1572,"language":268,"meta":257,"style":257},"\u003C?php\n\ndeclare(strict_types=1);\n\nuse App\\Models\\Comment;\nuse App\\Models\\Post;\nuse Illuminate\\Testing\\Fluent\\AssertableJson;\n\nit('returns comments', function () {\n    $post = Post::factory()->create();\n    $comments = Comment::factory()\n        ->count(2)\n        ->for($post)\n        ->create();\n\n    $this->getJson(route('posts.comments', $post))\n        ->assertJson(\n            fn (AssertableJson $json) => $json\n                ->has(\n                    'data',\n                    2,\n                    fn (AssertableJson $json) => $json\n                        ->where('id', $comments->first()->id)\n                        ->where('content', $comments->first()->content)\n                        ->has(\n                            'author',\n                            fn (AssertableJson $json) => $json\n                                ->where('name', $comments->first()->user->name)\n                                ->where('username', $comments->first()->user->username)\n                                ->where('avatar', $comments->first()->user->avatar)\n                        )\n                )\n        );\n});\n","tests\u002FFeature\u002FHttp\u002FApi\u002FPost\u002FComment\u002FIndexTest.php",[59,1574,1575,1579,1583,1587,1591,1595,1599,1604,1608,1613,1618,1623,1628,1633,1637,1641,1646,1651,1656,1661,1666,1671,1676,1681,1686,1691,1696,1701,1706,1711,1716,1721,1727,1733],{"__ignoreMap":257},[261,1576,1577],{"class":263,"line":264},[261,1578,598],{},[261,1580,1581],{"class":263,"line":288},[261,1582,454],{"emptyLinePlaceholder":453},[261,1584,1585],{"class":263,"line":316},[261,1586,607],{},[261,1588,1589],{"class":263,"line":347},[261,1590,454],{"emptyLinePlaceholder":453},[261,1592,1593],{"class":263,"line":373},[261,1594,933],{},[261,1596,1597],{"class":263,"line":457},[261,1598,616],{},[261,1600,1601],{"class":263,"line":463},[261,1602,1603],{},"use Illuminate\\Testing\\Fluent\\AssertableJson;\n",[261,1605,1606],{"class":263,"line":469},[261,1607,454],{"emptyLinePlaceholder":453},[261,1609,1610],{"class":263,"line":474},[261,1611,1612],{},"it('returns comments', function () {\n",[261,1614,1615],{"class":263,"line":480},[261,1616,1617],{},"    $post = Post::factory()->create();\n",[261,1619,1620],{"class":263,"line":486},[261,1621,1622],{},"    $comments = Comment::factory()\n",[261,1624,1625],{"class":263,"line":647},[261,1626,1627],{},"        ->count(2)\n",[261,1629,1630],{"class":263,"line":653},[261,1631,1632],{},"        ->for($post)\n",[261,1634,1635],{"class":263,"line":659},[261,1636,1306],{},[261,1638,1639],{"class":263,"line":665},[261,1640,454],{"emptyLinePlaceholder":453},[261,1642,1643],{"class":263,"line":671},[261,1644,1645],{},"    $this->getJson(route('posts.comments', $post))\n",[261,1647,1648],{"class":263,"line":677},[261,1649,1650],{},"        ->assertJson(\n",[261,1652,1653],{"class":263,"line":683},[261,1654,1655],{},"            fn (AssertableJson $json) => $json\n",[261,1657,1658],{"class":263,"line":993},[261,1659,1660],{},"                ->has(\n",[261,1662,1663],{"class":263,"line":1171},[261,1664,1665],{},"                    'data',\n",[261,1667,1668],{"class":263,"line":1177},[261,1669,1670],{},"                    2,\n",[261,1672,1673],{"class":263,"line":1182},[261,1674,1675],{},"                    fn (AssertableJson $json) => $json\n",[261,1677,1678],{"class":263,"line":1478},[261,1679,1680],{},"                        ->where('id', $comments->first()->id)\n",[261,1682,1683],{"class":263,"line":1483},[261,1684,1685],{},"                        ->where('content', $comments->first()->content)\n",[261,1687,1688],{"class":263,"line":1488},[261,1689,1690],{},"                        ->has(\n",[261,1692,1693],{"class":263,"line":1493},[261,1694,1695],{},"                            'author',\n",[261,1697,1698],{"class":263,"line":1499},[261,1699,1700],{},"                            fn (AssertableJson $json) => $json\n",[261,1702,1703],{"class":263,"line":1504},[261,1704,1705],{},"                                ->where('name', $comments->first()->user->name)\n",[261,1707,1708],{"class":263,"line":1509},[261,1709,1710],{},"                                ->where('username', $comments->first()->user->username)\n",[261,1712,1713],{"class":263,"line":1514},[261,1714,1715],{},"                                ->where('avatar', $comments->first()->user->avatar)\n",[261,1717,1718],{"class":263,"line":1520},[261,1719,1720],{},"                        )\n",[261,1722,1724],{"class":263,"line":1723},32,[261,1725,1726],{},"                )\n",[261,1728,1730],{"class":263,"line":1729},33,[261,1731,1732],{},"        );\n",[261,1734,1736],{"class":263,"line":1735},34,[261,1737,686],{},[10,1739,1740,1741,708],{},"Pour les tests HTTP, j'utilise le pattern ",[59,1742,1743],{},"AAA",[17,1745,1746,1749,1752],{},[20,1747,1748],{},"Arrange : préparer les données",[20,1750,1751],{},"Act : appeler la méthode",[20,1753,1754],{},"Assert : vérifier le résultat",[10,1756,1757,1758,1761,1762,1764,1765,1768,1769,327],{},"Dans ce test, nous créons un article et deux commentaires associés. C'est l'étape ",[59,1759,1760],{},"Arrange",". Nous appelons ensuite ",[59,1763,1554],{},", l'étape ",[59,1766,1767],{},"Act",". Enfin, nous vérifions que la réponse contient deux commentaires avec la structure attendue, l'étape ",[59,1770,1771],{},"Assert",[10,1773,1774,1775,708],{},"Le test en échec nous demande d'ajouter une route dans ",[59,1776,379],{},[251,1778,1780],{"className":424,"code":1779,"filename":379,"language":268,"meta":257,"style":257},"\u003C?php\n\nuse Illuminate\\Support\\Facades\\Route;\nuse App\\Http\\Controllers\\Api\\PostCommentController;\n\nRoute::get('\u002Fposts\u002F{post}\u002Fcomments', [PostCommentController::class, 'index'])\n    ->name('posts.comments');\n",[59,1781,1782,1786,1790,1795,1800,1804,1809],{"__ignoreMap":257},[261,1783,1784],{"class":263,"line":264},[261,1785,598],{},[261,1787,1788],{"class":263,"line":288},[261,1789,454],{"emptyLinePlaceholder":453},[261,1791,1792],{"class":263,"line":316},[261,1793,1794],{},"use Illuminate\\Support\\Facades\\Route;\n",[261,1796,1797],{"class":263,"line":347},[261,1798,1799],{},"use App\\Http\\Controllers\\Api\\PostCommentController;\n",[261,1801,1802],{"class":263,"line":373},[261,1803,454],{"emptyLinePlaceholder":453},[261,1805,1806],{"class":263,"line":457},[261,1807,1808],{},"Route::get('\u002Fposts\u002F{post}\u002Fcomments', [PostCommentController::class, 'index'])\n",[261,1810,1811],{"class":263,"line":463},[261,1812,1813],{},"    ->name('posts.comments');\n",[10,1815,1816,1817,708],{},"Nous devons ensuite demander à Laravel de lire ce fichier en mettant à jour ",[59,1818,1819],{},"bootstrap\u002Fapp.php",[251,1821,1823],{"className":424,"code":1822,"filename":1819,"language":268,"meta":257,"style":257},"\u003C?php\n\ndeclare(strict_types=1);\n\nuse Illuminate\\Foundation\\Application;\nuse Illuminate\\Foundation\\Configuration\\Exceptions;\nuse Illuminate\\Foundation\\Configuration\\Middleware;\n\nreturn Application::configure(basePath: dirname(__DIR__))\n    ->withRouting(\n        web: __DIR__.'\u002F..\u002Froutes\u002Fweb.php',\n        api: __DIR__.'\u002F..\u002Froutes\u002Fapi.php', \u002F\u002F [!code ++]\n        commands: __DIR__.'\u002F..\u002Froutes\u002Fconsole.php',\n        health: '\u002Fup',\n    )\n",[59,1824,1825,1829,1833,1837,1841,1846,1851,1856,1860,1865,1870,1875,1880,1885,1890],{"__ignoreMap":257},[261,1826,1827],{"class":263,"line":264},[261,1828,598],{},[261,1830,1831],{"class":263,"line":288},[261,1832,454],{"emptyLinePlaceholder":453},[261,1834,1835],{"class":263,"line":316},[261,1836,607],{},[261,1838,1839],{"class":263,"line":347},[261,1840,454],{"emptyLinePlaceholder":453},[261,1842,1843],{"class":263,"line":373},[261,1844,1845],{},"use Illuminate\\Foundation\\Application;\n",[261,1847,1848],{"class":263,"line":457},[261,1849,1850],{},"use Illuminate\\Foundation\\Configuration\\Exceptions;\n",[261,1852,1853],{"class":263,"line":463},[261,1854,1855],{},"use Illuminate\\Foundation\\Configuration\\Middleware;\n",[261,1857,1858],{"class":263,"line":469},[261,1859,454],{"emptyLinePlaceholder":453},[261,1861,1862],{"class":263,"line":474},[261,1863,1864],{},"return Application::configure(basePath: dirname(__DIR__))\n",[261,1866,1867],{"class":263,"line":480},[261,1868,1869],{},"    ->withRouting(\n",[261,1871,1872],{"class":263,"line":486},[261,1873,1874],{},"        web: __DIR__.'\u002F..\u002Froutes\u002Fweb.php',\n",[261,1876,1877],{"class":263,"line":647},[261,1878,1879],{},"        api: __DIR__.'\u002F..\u002Froutes\u002Fapi.php', \u002F\u002F [!code ++]\n",[261,1881,1882],{"class":263,"line":653},[261,1883,1884],{},"        commands: __DIR__.'\u002F..\u002Froutes\u002Fconsole.php',\n",[261,1886,1887],{"class":263,"line":659},[261,1888,1889],{},"        health: '\u002Fup',\n",[261,1891,1892],{"class":263,"line":665},[261,1893,1894],{},"    )\n",[10,1896,1897,1898,708],{},"Enfin, créons le contrôleur avec une méthode ",[59,1899,1550],{},[251,1901,1902],{"className":253,"code":357,"filename":255,"language":256,"meta":257,"style":257},[59,1903,1904],{"__ignoreMap":257},[261,1905,1906,1908,1910,1912],{"class":263,"line":264},[261,1907,268],{"class":267},[261,1909,272],{"class":271},[261,1911,341],{"class":271},[261,1913,370],{"class":271},[251,1915,1918],{"className":424,"code":1916,"filename":1917,"language":268,"meta":257,"style":257},"\u003C?php\n\nnamespace App\\Http\\Controllers\\Api;\n\nuse App\\Http\\Controllers\\Controller;\nuse Illuminate\\Http\\Request;\n\nclass PostCommentController extends Controller\n{\n    public function index(Request $request)\n    {\n        \u002F\u002F\n    }\n}\n","app\u002FHttp\u002FApi\u002FPostCommentController.php",[59,1919,1920,1924,1928,1933,1937,1942,1947,1951,1956,1960,1965,1969,1974,1978],{"__ignoreMap":257},[261,1921,1922],{"class":263,"line":264},[261,1923,598],{},[261,1925,1926],{"class":263,"line":288},[261,1927,454],{"emptyLinePlaceholder":453},[261,1929,1930],{"class":263,"line":316},[261,1931,1932],{},"namespace App\\Http\\Controllers\\Api;\n",[261,1934,1935],{"class":263,"line":347},[261,1936,454],{"emptyLinePlaceholder":453},[261,1938,1939],{"class":263,"line":373},[261,1940,1941],{},"use App\\Http\\Controllers\\Controller;\n",[261,1943,1944],{"class":263,"line":457},[261,1945,1946],{},"use Illuminate\\Http\\Request;\n",[261,1948,1949],{"class":263,"line":463},[261,1950,454],{"emptyLinePlaceholder":453},[261,1952,1953],{"class":263,"line":469},[261,1954,1955],{},"class PostCommentController extends Controller\n",[261,1957,1958],{"class":263,"line":474},[261,1959,438],{},[261,1961,1962],{"class":263,"line":480},[261,1963,1964],{},"    public function index(Request $request)\n",[261,1966,1967],{"class":263,"line":486},[261,1968,518],{},[261,1970,1971],{"class":263,"line":647},[261,1972,1973],{},"        \u002F\u002F\n",[261,1975,1976],{"class":263,"line":653},[261,1977,547],{},[261,1979,1980],{"class":263,"line":659},[261,1981,552],{},[10,1983,1984],{},"La route existe maintenant, mais le test indique que la réponse n'est pas un JSON valide, car le contrôleur ne retourne rien. 😄",[10,1986,1987],{},"Utilisons cet échec comme prochaine étape d'implémentation :",[251,1989,1991],{"className":424,"code":1990,"filename":1917,"language":268,"meta":257,"style":257},"\u003C?php\n\ndeclare(strict_types=1);\n\nnamespace App\\Http\\Controllers\\Api;\n\nuse App\\Http\\Controllers\\Controller;\nuse App\\Http\\Resources\\CommentResource;\nuse App\\Models\\Comment;\nuse Illuminate\\Http\\Resources\\Json\\ResourceCollection;\n\nfinal class PostCommentController extends Controller\n{\n    public function index(): ResourceCollection\n    {\n        $comments = Comment::query()\n          ->with('user')\n          ->get();\n\n        return CommentResource::collection($comments);\n    }\n}\n",[59,1992,1993,1997,2001,2005,2009,2013,2017,2021,2026,2030,2035,2039,2044,2048,2053,2057,2062,2067,2072,2076,2081,2085],{"__ignoreMap":257},[261,1994,1995],{"class":263,"line":264},[261,1996,598],{},[261,1998,1999],{"class":263,"line":288},[261,2000,454],{"emptyLinePlaceholder":453},[261,2002,2003],{"class":263,"line":316},[261,2004,607],{},[261,2006,2007],{"class":263,"line":347},[261,2008,454],{"emptyLinePlaceholder":453},[261,2010,2011],{"class":263,"line":373},[261,2012,1932],{},[261,2014,2015],{"class":263,"line":457},[261,2016,454],{"emptyLinePlaceholder":453},[261,2018,2019],{"class":263,"line":463},[261,2020,1941],{},[261,2022,2023],{"class":263,"line":469},[261,2024,2025],{},"use App\\Http\\Resources\\CommentResource;\n",[261,2027,2028],{"class":263,"line":474},[261,2029,933],{},[261,2031,2032],{"class":263,"line":480},[261,2033,2034],{},"use Illuminate\\Http\\Resources\\Json\\ResourceCollection;\n",[261,2036,2037],{"class":263,"line":486},[261,2038,454],{"emptyLinePlaceholder":453},[261,2040,2041],{"class":263,"line":647},[261,2042,2043],{},"final class PostCommentController extends Controller\n",[261,2045,2046],{"class":263,"line":653},[261,2047,438],{},[261,2049,2050],{"class":263,"line":659},[261,2051,2052],{},"    public function index(): ResourceCollection\n",[261,2054,2055],{"class":263,"line":665},[261,2056,518],{},[261,2058,2059],{"class":263,"line":671},[261,2060,2061],{},"        $comments = Comment::query()\n",[261,2063,2064],{"class":263,"line":677},[261,2065,2066],{},"          ->with('user')\n",[261,2068,2069],{"class":263,"line":683},[261,2070,2071],{},"          ->get();\n",[261,2073,2074],{"class":263,"line":993},[261,2075,454],{"emptyLinePlaceholder":453},[261,2077,2078],{"class":263,"line":1171},[261,2079,2080],{},"        return CommentResource::collection($comments);\n",[261,2082,2083],{"class":263,"line":1177},[261,2084,547],{},[261,2086,2087],{"class":263,"line":1182},[261,2088,552],{},[10,2090,2091,2092,2094,2095,327],{},"La méthode ",[59,2093,1550],{}," récupère les commentaires, charge la relation utilisateur à l'avance et retourne une collection de ressources ",[59,2096,2097],{},"CommentResource",[36,2099,2100],{"color":38,"icon":39},[10,2101,2102],{},"Récupérer tous les enregistrements n'est généralement pas une bonne pratique ; la pagination est plus sûre pour une grande collection. Dans cet exemple, nous nous attendons à un petit nombre de commentaires, le retour de la collection est donc acceptable. Nous pourrons ajouter la pagination si cette hypothèse change.",[10,2104,2105,2106,708],{},"Créons maintenant la classe ",[59,2107,2097],{},[251,2109,2111],{"className":253,"code":2110,"filename":255,"language":256,"meta":257,"style":257},"php artisan make:resource CommentResource\n",[59,2112,2113],{"__ignoreMap":257},[261,2114,2115,2117,2119,2122],{"class":263,"line":264},[261,2116,268],{"class":267},[261,2118,272],{"class":271},[261,2120,2121],{"class":271}," make:resource",[261,2123,2124],{"class":271}," CommentResource\n",[251,2126,2129],{"className":424,"code":2127,"filename":2128,"language":268,"meta":257,"style":257},"\u003C?php\n\ndeclare(strict_types=1);\n\nnamespace App\\Http\\Resources;\n\nuse App\\Models\\Comment;\nuse Illuminate\\Http\\Request;\nuse Illuminate\\Http\\Resources\\Json\\JsonResource;\n\n\u002F**\n * @mixin Comment\n *\u002F\nfinal class CommentResource extends JsonResource\n{\n    \u002F**\n     * Transform the resource into an array.\n     *\n     * @return array\u003Cstring, mixed>\n     *\u002F\n    public function toArray(Request $request): array\n    {\n        return [\n            'id' => $this->id,\n            'content' => $this->content,\n            'author' => UserResource::make($this->whenLoaded('user')),\n        ];\n    }\n}\n","app\u002FHttp\u002FResources\u002FCommentResource.php",[59,2130,2131,2135,2139,2143,2147,2152,2156,2160,2164,2169,2173,2178,2183,2188,2193,2197,2201,2206,2210,2215,2219,2224,2228,2232,2237,2242,2247,2251,2255],{"__ignoreMap":257},[261,2132,2133],{"class":263,"line":264},[261,2134,598],{},[261,2136,2137],{"class":263,"line":288},[261,2138,454],{"emptyLinePlaceholder":453},[261,2140,2141],{"class":263,"line":316},[261,2142,607],{},[261,2144,2145],{"class":263,"line":347},[261,2146,454],{"emptyLinePlaceholder":453},[261,2148,2149],{"class":263,"line":373},[261,2150,2151],{},"namespace App\\Http\\Resources;\n",[261,2153,2154],{"class":263,"line":457},[261,2155,454],{"emptyLinePlaceholder":453},[261,2157,2158],{"class":263,"line":463},[261,2159,933],{},[261,2161,2162],{"class":263,"line":469},[261,2163,1946],{},[261,2165,2166],{"class":263,"line":474},[261,2167,2168],{},"use Illuminate\\Http\\Resources\\Json\\JsonResource;\n",[261,2170,2171],{"class":263,"line":480},[261,2172,454],{"emptyLinePlaceholder":453},[261,2174,2175],{"class":263,"line":486},[261,2176,2177],{},"\u002F**\n",[261,2179,2180],{"class":263,"line":647},[261,2181,2182],{}," * @mixin Comment\n",[261,2184,2185],{"class":263,"line":653},[261,2186,2187],{}," *\u002F\n",[261,2189,2190],{"class":263,"line":659},[261,2191,2192],{},"final class CommentResource extends JsonResource\n",[261,2194,2195],{"class":263,"line":665},[261,2196,438],{},[261,2198,2199],{"class":263,"line":671},[261,2200,1036],{},[261,2202,2203],{"class":263,"line":677},[261,2204,2205],{},"     * Transform the resource into an array.\n",[261,2207,2208],{"class":263,"line":683},[261,2209,1046],{},[261,2211,2212],{"class":263,"line":993},[261,2213,2214],{},"     * @return array\u003Cstring, mixed>\n",[261,2216,2217],{"class":263,"line":1171},[261,2218,1056],{},[261,2220,2221],{"class":263,"line":1177},[261,2222,2223],{},"    public function toArray(Request $request): array\n",[261,2225,2226],{"class":263,"line":1182},[261,2227,518],{},[261,2229,2230],{"class":263,"line":1478},[261,2231,523],{},[261,2233,2234],{"class":263,"line":1483},[261,2235,2236],{},"            'id' => $this->id,\n",[261,2238,2239],{"class":263,"line":1488},[261,2240,2241],{},"            'content' => $this->content,\n",[261,2243,2244],{"class":263,"line":1493},[261,2245,2246],{},"            'author' => UserResource::make($this->whenLoaded('user')),\n",[261,2248,2249],{"class":263,"line":1499},[261,2250,542],{},[261,2252,2253],{"class":263,"line":1504},[261,2254,547],{},[261,2256,2257],{"class":263,"line":1509},[261,2258,552],{},[10,2260,2261],{},"Et une seconde ressource pour l'auteur :",[251,2263,2265],{"className":253,"code":2264,"filename":255,"language":256,"meta":257,"style":257},"php artisan make:resource UserResource\n",[59,2266,2267],{"__ignoreMap":257},[261,2268,2269,2271,2273,2275],{"class":263,"line":264},[261,2270,268],{"class":267},[261,2272,272],{"class":271},[261,2274,2121],{"class":271},[261,2276,2277],{"class":271}," UserResource\n",[251,2279,2282],{"className":424,"code":2280,"filename":2281,"language":268,"meta":257,"style":257},"\u003C?php\n\ndeclare(strict_types=1);\n\nnamespace App\\Http\\Resources;\n\nuse App\\Models\\User;\nuse Illuminate\\Http\\Request;\nuse Illuminate\\Http\\Resources\\Json\\JsonResource;\n\n\u002F**\n * @mixin User\n *\u002F\nfinal class UserResource extends JsonResource\n{\n    \u002F**\n     * Transform the resource into an array.\n     *\n     * @return array\u003Cstring, mixed>\n     *\u002F\n    public function toArray(Request $request): array\n    {\n        return [\n            'name' => $this->name,\n            'username' => $this->username,\n            'avatar' => $this->avatar,\n        ];\n    }\n}\n","app\u002FHttp\u002FResources\u002FUserResource.php",[59,2283,2284,2288,2292,2296,2300,2304,2308,2312,2316,2320,2324,2328,2333,2337,2342,2346,2350,2354,2358,2362,2366,2370,2374,2378,2383,2388,2393,2397,2401],{"__ignoreMap":257},[261,2285,2286],{"class":263,"line":264},[261,2287,598],{},[261,2289,2290],{"class":263,"line":288},[261,2291,454],{"emptyLinePlaceholder":453},[261,2293,2294],{"class":263,"line":316},[261,2295,607],{},[261,2297,2298],{"class":263,"line":347},[261,2299,454],{"emptyLinePlaceholder":453},[261,2301,2302],{"class":263,"line":373},[261,2303,2151],{},[261,2305,2306],{"class":263,"line":457},[261,2307,454],{"emptyLinePlaceholder":453},[261,2309,2310],{"class":263,"line":463},[261,2311,1333],{},[261,2313,2314],{"class":263,"line":469},[261,2315,1946],{},[261,2317,2318],{"class":263,"line":474},[261,2319,2168],{},[261,2321,2322],{"class":263,"line":480},[261,2323,454],{"emptyLinePlaceholder":453},[261,2325,2326],{"class":263,"line":486},[261,2327,2177],{},[261,2329,2330],{"class":263,"line":647},[261,2331,2332],{}," * @mixin User\n",[261,2334,2335],{"class":263,"line":653},[261,2336,2187],{},[261,2338,2339],{"class":263,"line":659},[261,2340,2341],{},"final class UserResource extends JsonResource\n",[261,2343,2344],{"class":263,"line":665},[261,2345,438],{},[261,2347,2348],{"class":263,"line":671},[261,2349,1036],{},[261,2351,2352],{"class":263,"line":677},[261,2353,2205],{},[261,2355,2356],{"class":263,"line":683},[261,2357,1046],{},[261,2359,2360],{"class":263,"line":993},[261,2361,2214],{},[261,2363,2364],{"class":263,"line":1171},[261,2365,1056],{},[261,2367,2368],{"class":263,"line":1177},[261,2369,2223],{},[261,2371,2372],{"class":263,"line":1182},[261,2373,518],{},[261,2375,2376],{"class":263,"line":1478},[261,2377,523],{},[261,2379,2380],{"class":263,"line":1483},[261,2381,2382],{},"            'name' => $this->name,\n",[261,2384,2385],{"class":263,"line":1488},[261,2386,2387],{},"            'username' => $this->username,\n",[261,2389,2390],{"class":263,"line":1493},[261,2391,2392],{},"            'avatar' => $this->avatar,\n",[261,2394,2395],{"class":263,"line":1499},[261,2396,542],{},[261,2398,2399],{"class":263,"line":1504},[261,2400,547],{},[261,2402,2403],{"class":263,"line":1509},[261,2404,552],{},[10,2406,2407],{},"Que sont ces ressources ?",[10,2409,2410],{},"Une ressource est une couche de transformation entre nos modèles Eloquent et les réponses JSON envoyées au client. Elle définit comment un modèle est transformé en JSON.",[10,2412,2413,2414,2416,2417,2419,2420,2423,2424,2416,2427,2419,2430,2433],{},"Ici, nous retournons l'",[59,2415,61],{},", le ",[59,2418,79],{}," et l'",[59,2421,2422],{},"author"," d'un commentaire. La ressource imbriquée de l'auteur n'expose que le ",[59,2425,2426],{},"name",[59,2428,2429],{},"username",[59,2431,2432],{},"avatar"," de l'utilisateur. Cela permet de modifier la forme de la réponse sans toucher au contrôleur et évite d'exposer accidentellement des champs comme l'e-mail de l'utilisateur.",[10,2435,2436],{},"Le test devrait maintenant réussir. Mais ne nous précipitons pas : ajoutons un test pour vérifier que cette méthode ne retourne que les commentaires de l'article demandé :",[251,2438,2440],{"className":424,"code":2439,"filename":1572,"language":268,"meta":257,"style":257},"it('returns comments for a post', function () {\n    Comment::factory()\n        ->count(2)\n        ->create();\n\n    $this->getJson(route('posts.comments', Post::factory()->create()))\n        ->assertJson(\n            fn (AssertableJson $json) => $json\n                ->has('data', 0)\n        );\n});\n",[59,2441,2442,2447,2452,2456,2460,2464,2469,2473,2477,2482,2486],{"__ignoreMap":257},[261,2443,2444],{"class":263,"line":264},[261,2445,2446],{},"it('returns comments for a post', function () {\n",[261,2448,2449],{"class":263,"line":288},[261,2450,2451],{},"    Comment::factory()\n",[261,2453,2454],{"class":263,"line":316},[261,2455,1627],{},[261,2457,2458],{"class":263,"line":347},[261,2459,1306],{},[261,2461,2462],{"class":263,"line":373},[261,2463,454],{"emptyLinePlaceholder":453},[261,2465,2466],{"class":263,"line":457},[261,2467,2468],{},"    $this->getJson(route('posts.comments', Post::factory()->create()))\n",[261,2470,2471],{"class":263,"line":463},[261,2472,1650],{},[261,2474,2475],{"class":263,"line":469},[261,2476,1655],{},[261,2478,2479],{"class":263,"line":474},[261,2480,2481],{},"                ->has('data', 0)\n",[261,2483,2484],{"class":263,"line":480},[261,2485,1732],{},[261,2487,2488],{"class":263,"line":486},[261,2489,686],{},[10,2491,2492],{},"Ce test crée deux commentaires pour un article, appelle la route avec un autre article et attend une réponse vide.",[10,2494,2495],{},"Le test échoue, car le contrôleur ne filtre pas encore les commentaires par article.",[10,2497,2498,2499,708],{},"Corrigeons la méthode ",[59,2500,1550],{},[251,2502,2504],{"className":424,"code":2503,"filename":1917,"language":268,"meta":257,"style":257},"use App\\Models\\Post;\n\nfinal class PostCommentController extends Controller\n{\n    public function index(Post $post): ResourceCollection\n    {\n        $comments = Comment::query()\n            ->whereBelongsTo($post)\n            ->with('user')\n            ->get();\n\n        return CommentResource::collection($comments);\n    }\n}\n",[59,2505,2506,2510,2514,2518,2522,2527,2531,2535,2540,2545,2550,2554,2558,2562],{"__ignoreMap":257},[261,2507,2508],{"class":263,"line":264},[261,2509,616],{},[261,2511,2512],{"class":263,"line":288},[261,2513,454],{"emptyLinePlaceholder":453},[261,2515,2516],{"class":263,"line":316},[261,2517,2043],{},[261,2519,2520],{"class":263,"line":347},[261,2521,438],{},[261,2523,2524],{"class":263,"line":373},[261,2525,2526],{},"    public function index(Post $post): ResourceCollection\n",[261,2528,2529],{"class":263,"line":457},[261,2530,518],{},[261,2532,2533],{"class":263,"line":463},[261,2534,2061],{},[261,2536,2537],{"class":263,"line":469},[261,2538,2539],{},"            ->whereBelongsTo($post)\n",[261,2541,2542],{"class":263,"line":474},[261,2543,2544],{},"            ->with('user')\n",[261,2546,2547],{"class":263,"line":480},[261,2548,2549],{},"            ->get();\n",[261,2551,2552],{"class":263,"line":486},[261,2553,454],{"emptyLinePlaceholder":453},[261,2555,2556],{"class":263,"line":647},[261,2557,2080],{},[261,2559,2560],{"class":263,"line":653},[261,2561,547],{},[261,2563,2564],{"class":263,"line":659},[261,2565,552],{},[10,2567,2568,2569,2571,2572,2575,2576,2578],{},"Le binding de modèle des routes de Laravel nous fournit directement l'instance ",[59,2570,121],{},". Comme la route contient ",[59,2573,2574],{},"{post}"," et que la méthode accepte un ",[59,2577,121],{},", Laravel recherche l'enregistrement correspondant et l'injecte. Le contrôleur reste ainsi concis.",[10,2580,2581],{},"Les tests devraient maintenant réussir. 👌",[10,2583,2584,2585,327],{},"Passons à la méthode ",[59,2586,1559],{},[10,2588,2589],{},"Vous connaissez la méthode : commençons par écrire un test :",[251,2591,2594],{"className":424,"code":2592,"filename":2593,"language":268,"meta":257,"style":257},"\u003C?php\n\nuse App\\Models\\Post;\n\nit('requires authentication', function () {\n    $post = Post::factory()->create();\n\n    $this->postJson(route('posts.comments.store', $post))\n        ->assertUnauthorized();\n});\n","tests\u002FFeature\u002FHttp\u002FApi\u002FPost\u002FComment\u002FStoreTest.php",[59,2595,2596,2600,2604,2608,2612,2617,2621,2625,2630,2635],{"__ignoreMap":257},[261,2597,2598],{"class":263,"line":264},[261,2599,598],{},[261,2601,2602],{"class":263,"line":288},[261,2603,454],{"emptyLinePlaceholder":453},[261,2605,2606],{"class":263,"line":316},[261,2607,616],{},[261,2609,2610],{"class":263,"line":347},[261,2611,454],{"emptyLinePlaceholder":453},[261,2613,2614],{"class":263,"line":373},[261,2615,2616],{},"it('requires authentication', function () {\n",[261,2618,2619],{"class":263,"line":457},[261,2620,1617],{},[261,2622,2623],{"class":263,"line":463},[261,2624,454],{"emptyLinePlaceholder":453},[261,2626,2627],{"class":263,"line":469},[261,2628,2629],{},"    $this->postJson(route('posts.comments.store', $post))\n",[261,2631,2632],{"class":263,"line":474},[261,2633,2634],{},"        ->assertUnauthorized();\n",[261,2636,2637],{"class":263,"line":480},[261,2638,686],{},[10,2640,2641],{},"Ce test vérifie que l'authentification est requise. Ajoutez la route :",[251,2643,2645],{"className":424,"code":2644,"filename":379,"language":268,"meta":257,"style":257},"Route::middleware('auth')->group(function () {\n    Route::post('\u002Fposts\u002F{post}\u002Fcomments', [PostCommentController::class, 'store'])\n        ->name('posts.comments.store');\n});\n",[59,2646,2647,2652,2657,2662],{"__ignoreMap":257},[261,2648,2649],{"class":263,"line":264},[261,2650,2651],{},"Route::middleware('auth')->group(function () {\n",[261,2653,2654],{"class":263,"line":288},[261,2655,2656],{},"    Route::post('\u002Fposts\u002F{post}\u002Fcomments', [PostCommentController::class, 'store'])\n",[261,2658,2659],{"class":263,"line":316},[261,2660,2661],{},"        ->name('posts.comments.store');\n",[261,2663,2664],{"class":263,"line":347},[261,2665,686],{},[10,2667,2668],{},"Continuons avec un autre test :",[251,2670,2672],{"className":424,"code":2671,"filename":2593,"language":268,"meta":257,"style":257},"use App\\Models\\User;\n\n\u002F\u002F ...\n\nit('stores a comment', function () {\n    $user = User::factory()->create();\n    $post = Post::factory()->create();\n\n    $this->actingAs($user)\n        ->postJson(route('posts.comments.store', $post), [\n            'content' => 'This is a comment',\n        ]);\n\n    $this->assertDatabaseHas('comments', [\n        'post_id' => $post->id,\n        'user_id' => $user->id,\n        'content' => 'This is a comment',\n    ]);\n});\n",[59,2673,2674,2678,2682,2686,2690,2695,2700,2704,2708,2713,2718,2723,2727,2731,2736,2741,2746,2751,2756],{"__ignoreMap":257},[261,2675,2676],{"class":263,"line":264},[261,2677,1333],{},[261,2679,2680],{"class":263,"line":288},[261,2681,454],{"emptyLinePlaceholder":453},[261,2683,2684],{"class":263,"line":316},[261,2685,852],{},[261,2687,2688],{"class":263,"line":347},[261,2689,454],{"emptyLinePlaceholder":453},[261,2691,2692],{"class":263,"line":373},[261,2693,2694],{},"it('stores a comment', function () {\n",[261,2696,2697],{"class":263,"line":457},[261,2698,2699],{},"    $user = User::factory()->create();\n",[261,2701,2702],{"class":263,"line":463},[261,2703,1617],{},[261,2705,2706],{"class":263,"line":469},[261,2707,454],{"emptyLinePlaceholder":453},[261,2709,2710],{"class":263,"line":474},[261,2711,2712],{},"    $this->actingAs($user)\n",[261,2714,2715],{"class":263,"line":480},[261,2716,2717],{},"        ->postJson(route('posts.comments.store', $post), [\n",[261,2719,2720],{"class":263,"line":486},[261,2721,2722],{},"            'content' => 'This is a comment',\n",[261,2724,2725],{"class":263,"line":647},[261,2726,680],{},[261,2728,2729],{"class":263,"line":653},[261,2730,454],{"emptyLinePlaceholder":453},[261,2732,2733],{"class":263,"line":659},[261,2734,2735],{},"    $this->assertDatabaseHas('comments', [\n",[261,2737,2738],{"class":263,"line":665},[261,2739,2740],{},"        'post_id' => $post->id,\n",[261,2742,2743],{"class":263,"line":671},[261,2744,2745],{},"        'user_id' => $user->id,\n",[261,2747,2748],{"class":263,"line":677},[261,2749,2750],{},"        'content' => 'This is a comment',\n",[261,2752,2753],{"class":263,"line":683},[261,2754,2755],{},"    ]);\n",[261,2757,2758],{"class":263,"line":993},[261,2759,686],{},[10,2761,2762,2763,2765,2766,2768],{},"Ce test vérifie que le commentaire est enregistré avec le bon ",[59,2764,67],{},", le bon ",[59,2767,73],{}," et le bon contenu. Le contrôleur définit les deux clés étrangères.",[10,2770,2771,2772,708],{},"Nous pouvons maintenant implémenter la méthode ",[59,2773,1559],{},[251,2775,2777],{"className":424,"code":2776,"filename":1917,"language":268,"meta":257,"style":257},"final class PostCommentController extends Controller\n{\n    public function store(Request $request, Post $post)\n    {\n        Comment::create([\n            'post_id' => $post->id,\n            'user_id' => $request->user()->id,\n            'content' => $request->input('content')\n        ]);\n    }\n}\n",[59,2778,2779,2783,2787,2792,2796,2801,2806,2811,2816,2820,2824],{"__ignoreMap":257},[261,2780,2781],{"class":263,"line":264},[261,2782,2043],{},[261,2784,2785],{"class":263,"line":288},[261,2786,438],{},[261,2788,2789],{"class":263,"line":316},[261,2790,2791],{},"    public function store(Request $request, Post $post)\n",[261,2793,2794],{"class":263,"line":347},[261,2795,518],{},[261,2797,2798],{"class":263,"line":373},[261,2799,2800],{},"        Comment::create([\n",[261,2802,2803],{"class":263,"line":457},[261,2804,2805],{},"            'post_id' => $post->id,\n",[261,2807,2808],{"class":263,"line":463},[261,2809,2810],{},"            'user_id' => $request->user()->id,\n",[261,2812,2813],{"class":263,"line":469},[261,2814,2815],{},"            'content' => $request->input('content')\n",[261,2817,2818],{"class":263,"line":474},[261,2819,680],{},[261,2821,2822],{"class":263,"line":480},[261,2823,547],{},[261,2825,2826],{"class":263,"line":486},[261,2827,552],{},[36,2829,2830],{"color":38,"icon":39},[10,2831,2832],{},"Nous écrivons uniquement le minimum nécessaire pour faire réussir les tests. Cela ne signifie pas que l'implémentation est terminée. Par exemple, la requête doit encore être validée, ce que nous ajouterons avec le prochain test.",[10,2834,2835],{},"Ajoutons un test pour la validation de la requête :",[251,2837,2839],{"className":424,"code":2838,"filename":2593,"language":268,"meta":257,"style":257},"it('requires a valid data', function (array $badData, array|string $errors) {\n    $post = Post::factory()->create();\n\n    $response = $this->actingAs(User::factory()->create())\n        ->postJson(route('posts.comments.store', $post), $badData);\n\n    $response->assertJsonValidationErrors($errors);\n})->with([\n    [['content' => ''], ['content' => 'The content field is required.']],\n    [['content' => 1], ['content' => 'The content field must be a string.']],\n    [['content' => 'a'], ['content' => 'The content field must be at least 6 characters.']],\n    [['content' => 'a'.str_repeat('a', 2001)], ['content' => 'The content field must not be greater than 2000 characters.']],\n]);\n",[59,2840,2841,2846,2850,2854,2859,2864,2868,2873,2878,2883,2888,2893,2898],{"__ignoreMap":257},[261,2842,2843],{"class":263,"line":264},[261,2844,2845],{},"it('requires a valid data', function (array $badData, array|string $errors) {\n",[261,2847,2848],{"class":263,"line":288},[261,2849,1617],{},[261,2851,2852],{"class":263,"line":316},[261,2853,454],{"emptyLinePlaceholder":453},[261,2855,2856],{"class":263,"line":347},[261,2857,2858],{},"    $response = $this->actingAs(User::factory()->create())\n",[261,2860,2861],{"class":263,"line":373},[261,2862,2863],{},"        ->postJson(route('posts.comments.store', $post), $badData);\n",[261,2865,2866],{"class":263,"line":457},[261,2867,454],{"emptyLinePlaceholder":453},[261,2869,2870],{"class":263,"line":463},[261,2871,2872],{},"    $response->assertJsonValidationErrors($errors);\n",[261,2874,2875],{"class":263,"line":469},[261,2876,2877],{},"})->with([\n",[261,2879,2880],{"class":263,"line":474},[261,2881,2882],{},"    [['content' => ''], ['content' => 'The content field is required.']],\n",[261,2884,2885],{"class":263,"line":480},[261,2886,2887],{},"    [['content' => 1], ['content' => 'The content field must be a string.']],\n",[261,2889,2890],{"class":263,"line":486},[261,2891,2892],{},"    [['content' => 'a'], ['content' => 'The content field must be at least 6 characters.']],\n",[261,2894,2895],{"class":263,"line":647},[261,2896,2897],{},"    [['content' => 'a'.str_repeat('a', 2001)], ['content' => 'The content field must not be greater than 2000 characters.']],\n",[261,2899,2900],{"class":263,"line":653},[261,2901,2902],{},"]);\n",[10,2904,2905],{},"Pest exécute ce test quatre fois avec des données différentes. Un dataset permet de couvrir plusieurs entrées invalides sans dupliquer le corps du test.",[10,2907,2908,2909,2912],{},"Créons une classe ",[59,2910,2911],{},"StoreCommentRequest"," pour contenir ces règles :",[251,2914,2916],{"className":253,"code":2915,"filename":255,"language":256,"meta":257,"style":257},"php artisan make:request StoreCommentRequest\n",[59,2917,2918],{"__ignoreMap":257},[261,2919,2920,2922,2924,2927],{"class":263,"line":264},[261,2921,268],{"class":267},[261,2923,272],{"class":271},[261,2925,2926],{"class":271}," make:request",[261,2928,2929],{"class":271}," StoreCommentRequest\n",[251,2931,2934],{"className":424,"code":2932,"filename":2933,"language":268,"meta":257,"style":257},"\u003C?php\n\nnamespace App\\Http\\Requests;\n\nuse Illuminate\\Foundation\\Http\\FormRequest;\n\nclass StoreCommentRequest extends FormRequest\n{\n    \u002F**\n     * Get the validation rules that apply to the request.\n     *\n     * @return array\u003Cstring, \\Illuminate\\Contracts\\Validation\\ValidationRule|array\u003Cmixed>|string>\n     *\u002F\n    public function rules(): array\n    {\n        return [\n            'content' => ['required', 'string', 'max:2000', 'min:6'],\n        ];\n    }\n}\n","app\u002FHttp\u002FRequests\u002FStoreCommentRequest.php",[59,2935,2936,2940,2944,2949,2953,2958,2962,2967,2971,2975,2980,2984,2989,2993,2998,3002,3006,3011,3015,3019],{"__ignoreMap":257},[261,2937,2938],{"class":263,"line":264},[261,2939,598],{},[261,2941,2942],{"class":263,"line":288},[261,2943,454],{"emptyLinePlaceholder":453},[261,2945,2946],{"class":263,"line":316},[261,2947,2948],{},"namespace App\\Http\\Requests;\n",[261,2950,2951],{"class":263,"line":347},[261,2952,454],{"emptyLinePlaceholder":453},[261,2954,2955],{"class":263,"line":373},[261,2956,2957],{},"use Illuminate\\Foundation\\Http\\FormRequest;\n",[261,2959,2960],{"class":263,"line":457},[261,2961,454],{"emptyLinePlaceholder":453},[261,2963,2964],{"class":263,"line":463},[261,2965,2966],{},"class StoreCommentRequest extends FormRequest\n",[261,2968,2969],{"class":263,"line":469},[261,2970,438],{},[261,2972,2973],{"class":263,"line":474},[261,2974,1036],{},[261,2976,2977],{"class":263,"line":480},[261,2978,2979],{},"     * Get the validation rules that apply to the request.\n",[261,2981,2982],{"class":263,"line":486},[261,2983,1046],{},[261,2985,2986],{"class":263,"line":647},[261,2987,2988],{},"     * @return array\u003Cstring, \\Illuminate\\Contracts\\Validation\\ValidationRule|array\u003Cmixed>|string>\n",[261,2990,2991],{"class":263,"line":653},[261,2992,1056],{},[261,2994,2995],{"class":263,"line":659},[261,2996,2997],{},"    public function rules(): array\n",[261,2999,3000],{"class":263,"line":665},[261,3001,518],{},[261,3003,3004],{"class":263,"line":671},[261,3005,523],{},[261,3007,3008],{"class":263,"line":677},[261,3009,3010],{},"            'content' => ['required', 'string', 'max:2000', 'min:6'],\n",[261,3012,3013],{"class":263,"line":683},[261,3014,542],{},[261,3016,3017],{"class":263,"line":993},[261,3018,547],{},[261,3020,3021],{"class":263,"line":1171},[261,3022,552],{},[10,3024,3025,3026,3028],{},"Mettez à jour ",[59,3027,1559],{}," pour utiliser la nouvelle requête :",[251,3030,3032],{"className":424,"code":3031,"filename":1917,"language":268,"meta":257,"style":257},"use App\\Http\\Requests\\StoreCommentRequest; \u002F\u002F [!code --]\nuse Illuminate\\Http\\Request; \u002F\u002F [!code --]\n\nfinal class PostCommentController extends Controller\n{\n    public function store(StoreCommentRequest $request, Post $post) \u002F\u002F [!code highlight]\n    {\n        \u002F\u002F ...\n    }\n}\n",[59,3033,3034,3039,3044,3048,3052,3056,3061,3065,3070,3074],{"__ignoreMap":257},[261,3035,3036],{"class":263,"line":264},[261,3037,3038],{},"use App\\Http\\Requests\\StoreCommentRequest; \u002F\u002F [!code --]\n",[261,3040,3041],{"class":263,"line":288},[261,3042,3043],{},"use Illuminate\\Http\\Request; \u002F\u002F [!code --]\n",[261,3045,3046],{"class":263,"line":316},[261,3047,454],{"emptyLinePlaceholder":453},[261,3049,3050],{"class":263,"line":347},[261,3051,2043],{},[261,3053,3054],{"class":263,"line":373},[261,3055,438],{},[261,3057,3058],{"class":263,"line":457},[261,3059,3060],{},"    public function store(StoreCommentRequest $request, Post $post) \u002F\u002F [!code highlight]\n",[261,3062,3063],{"class":263,"line":463},[261,3064,518],{},[261,3066,3067],{"class":263,"line":469},[261,3068,3069],{},"        \u002F\u002F ...\n",[261,3071,3072],{"class":263,"line":474},[261,3073,547],{},[261,3075,3076],{"class":263,"line":480},[261,3077,552],{},[10,3079,3080],{},"Laravel valide maintenant la requête avant d'exécuter le contrôleur. ✨",[10,3082,3083],{},"Ajoutons enfin un test pour vérifier que les données retournées sont correctes :",[251,3085,3087],{"className":424,"code":3086,"filename":2593,"language":268,"meta":257,"style":257},"it('returns the created comment', function () {\n    $user = User::factory()->create();\n    $post = Post::factory()->create();\n    $comment = Comment::factory()->make();\n\n    $response = $this->actingAs($user)\n        ->postJson(route('posts.comments.store', $post), [\n            'content' => $comment->content,\n        ]);\n\n    $comment = Comment::first();\n    $response\n        ->assertCreated()\n        ->assertJson(\n            fn (AssertableJson $json) => $json\n                ->has(\n                    'data',\n                    fn (AssertableJson $json) => $json\n                        ->where('id', $comment->id)\n                        ->where('content', $comment->content)\n                        ->has(\n                            'author',\n                            fn (AssertableJson $json) => $json\n                                ->where('name', $user->name)\n                                ->where('username', $user->username)\n                                ->where('avatar', $user->avatar)\n                        )\n                )\n        );\n});\n",[59,3088,3089,3094,3098,3102,3107,3111,3116,3120,3125,3129,3133,3138,3143,3148,3152,3156,3160,3164,3168,3173,3178,3182,3186,3190,3195,3200,3205,3209,3213,3217],{"__ignoreMap":257},[261,3090,3091],{"class":263,"line":264},[261,3092,3093],{},"it('returns the created comment', function () {\n",[261,3095,3096],{"class":263,"line":288},[261,3097,2699],{},[261,3099,3100],{"class":263,"line":316},[261,3101,1617],{},[261,3103,3104],{"class":263,"line":347},[261,3105,3106],{},"    $comment = Comment::factory()->make();\n",[261,3108,3109],{"class":263,"line":373},[261,3110,454],{"emptyLinePlaceholder":453},[261,3112,3113],{"class":263,"line":457},[261,3114,3115],{},"    $response = $this->actingAs($user)\n",[261,3117,3118],{"class":263,"line":463},[261,3119,2717],{},[261,3121,3122],{"class":263,"line":469},[261,3123,3124],{},"            'content' => $comment->content,\n",[261,3126,3127],{"class":263,"line":474},[261,3128,680],{},[261,3130,3131],{"class":263,"line":480},[261,3132,454],{"emptyLinePlaceholder":453},[261,3134,3135],{"class":263,"line":486},[261,3136,3137],{},"    $comment = Comment::first();\n",[261,3139,3140],{"class":263,"line":647},[261,3141,3142],{},"    $response\n",[261,3144,3145],{"class":263,"line":653},[261,3146,3147],{},"        ->assertCreated()\n",[261,3149,3150],{"class":263,"line":659},[261,3151,1650],{},[261,3153,3154],{"class":263,"line":665},[261,3155,1655],{},[261,3157,3158],{"class":263,"line":671},[261,3159,1660],{},[261,3161,3162],{"class":263,"line":677},[261,3163,1665],{},[261,3165,3166],{"class":263,"line":683},[261,3167,1675],{},[261,3169,3170],{"class":263,"line":993},[261,3171,3172],{},"                        ->where('id', $comment->id)\n",[261,3174,3175],{"class":263,"line":1171},[261,3176,3177],{},"                        ->where('content', $comment->content)\n",[261,3179,3180],{"class":263,"line":1177},[261,3181,1690],{},[261,3183,3184],{"class":263,"line":1182},[261,3185,1695],{},[261,3187,3188],{"class":263,"line":1478},[261,3189,1700],{},[261,3191,3192],{"class":263,"line":1483},[261,3193,3194],{},"                                ->where('name', $user->name)\n",[261,3196,3197],{"class":263,"line":1488},[261,3198,3199],{},"                                ->where('username', $user->username)\n",[261,3201,3202],{"class":263,"line":1493},[261,3203,3204],{},"                                ->where('avatar', $user->avatar)\n",[261,3206,3207],{"class":263,"line":1499},[261,3208,1720],{},[261,3210,3211],{"class":263,"line":1504},[261,3212,1726],{},[261,3214,3215],{"class":263,"line":1509},[261,3216,1732],{},[261,3218,3219],{"class":263,"line":1514},[261,3220,686],{},[10,3222,3223,3224,3227,3228,327],{},"Ce test vérifie les données retournées et s'assure que le code HTTP est ",[59,3225,3226],{},"201 Created"," grâce à ",[59,3229,3230],{},"assertCreated",[10,3232,3233,3234,3236],{},"Mettons à jour la méthode ",[59,3235,1559],{}," pour retourner le commentaire créé :",[251,3238,3240],{"className":424,"code":3239,"filename":1917,"language":268,"meta":257,"style":257},"use Illuminate\\Http\\Resources\\Json\\JsonResource;\n\nfinal class PostCommentController extends Controller\n{\n    public function store(StoreCommentRequest $request, Post $post): JsonResource\n    {\n        $comment = Comment::create([ \u002F\u002F [!code highlight]\n            'post_id' => $post->id,\n            'user_id' => $request->user()->id,\n            'content' => $request->input('content')\n        ]);\n\n        $comment->load('user'); \u002F\u002F [!code ++]\n\n        return CommentResource::make($comment); \u002F\u002F [!code ++]\n    }\n}\n",[59,3241,3242,3246,3250,3254,3258,3263,3267,3272,3276,3280,3284,3288,3292,3297,3301,3306,3310],{"__ignoreMap":257},[261,3243,3244],{"class":263,"line":264},[261,3245,2168],{},[261,3247,3248],{"class":263,"line":288},[261,3249,454],{"emptyLinePlaceholder":453},[261,3251,3252],{"class":263,"line":316},[261,3253,2043],{},[261,3255,3256],{"class":263,"line":347},[261,3257,438],{},[261,3259,3260],{"class":263,"line":373},[261,3261,3262],{},"    public function store(StoreCommentRequest $request, Post $post): JsonResource\n",[261,3264,3265],{"class":263,"line":457},[261,3266,518],{},[261,3268,3269],{"class":263,"line":463},[261,3270,3271],{},"        $comment = Comment::create([ \u002F\u002F [!code highlight]\n",[261,3273,3274],{"class":263,"line":469},[261,3275,2805],{},[261,3277,3278],{"class":263,"line":474},[261,3279,2810],{},[261,3281,3282],{"class":263,"line":480},[261,3283,2815],{},[261,3285,3286],{"class":263,"line":486},[261,3287,680],{},[261,3289,3290],{"class":263,"line":647},[261,3291,454],{"emptyLinePlaceholder":453},[261,3293,3294],{"class":263,"line":653},[261,3295,3296],{},"        $comment->load('user'); \u002F\u002F [!code ++]\n",[261,3298,3299],{"class":263,"line":659},[261,3300,454],{"emptyLinePlaceholder":453},[261,3302,3303],{"class":263,"line":665},[261,3304,3305],{},"        return CommentResource::make($comment); \u002F\u002F [!code ++]\n",[261,3307,3308],{"class":263,"line":671},[261,3309,547],{},[261,3311,3312],{"class":263,"line":677},[261,3313,552],{},[10,3315,3316],{},"Tous les tests devraient maintenant réussir.",[10,3318,3319],{},"Ces tests représentent les tests que vous pouvez écrire pour les autres contrôleurs.",[44,3321,3323],{"id":3322},"modifier-et-supprimer-des-commentaires","Modifier et supprimer des commentaires",[10,3325,3326],{},"Nous pouvons maintenant implémenter la modification et la suppression des commentaires.",[36,3328,3329],{"color":38,"icon":39},[10,3330,3331],{},"Je vais avancer plus vite ici, car le workflow est maintenant familier. Les tests complets sont inclus afin que vous puissiez suivre chaque exigence.",[10,3333,3334],{},"Pour la modification, créons un nouveau fichier de test :",[251,3336,3338],{"className":253,"code":3337,"filename":255,"language":256,"meta":257,"style":257},"mkdir -p tests\u002FHttp\u002FApi\u002FComment && touch tests\u002FHttp\u002FApi\u002FComment\u002FUpdateTest.php\n",[59,3339,3340],{"__ignoreMap":257},[261,3341,3342,3344,3346,3349,3351,3353],{"class":263,"line":264},[261,3343,568],{"class":267},[261,3345,571],{"class":281},[261,3347,3348],{"class":271}," tests\u002FHttp\u002FApi\u002FComment",[261,3350,578],{"class":577},[261,3352,581],{"class":267},[261,3354,3355],{"class":271}," tests\u002FHttp\u002FApi\u002FComment\u002FUpdateTest.php\n",[10,3357,3358],{},"Ajoutons ensuite le test suivant :",[251,3360,3363],{"className":424,"code":3361,"filename":3362,"language":268,"meta":257,"style":257},"\u003C?php\n\ndeclare(strict_types=1);\n\nuse App\\Models\\Comment;\nuse App\\Models\\User;\nuse Illuminate\\Testing\\Fluent\\AssertableJson;\n\nit('requires authentication', function () {\n    $comment = Comment::factory()->create();\n\n    $this->putJson(route('comments.update', $comment))\n        ->assertUnauthorized();\n});\n\nit('requires the user to be the author of the comment', function () {\n    $user = User::factory()->create();\n    $comment = Comment::factory()->create();\n\n    $this->actingAs($user)\n        ->putJson(route('comments.update', $comment), [\n            'content' => 'Updated content',\n        ])\n        ->assertForbidden();\n});\n\nit('updates a comment', function () {\n    $user = User::factory()->create();\n    $comment = Comment::factory()\n        ->for($user)\n        ->create();\n\n    $this->actingAs($user)\n        ->putJson(route('comments.update', $comment), [\n            'content' => 'Updated content',\n        ]);\n\n    $this->assertDatabaseHas('comments', [\n        'id' => $comment->id,\n        'content' => 'Updated content',\n    ]);\n});\n\nit('requires a valid data', function (array $badData, array|string $errors) {\n    $user = User::factory()->create();\n    $comment = Comment::factory()->for($user)->create();\n\n    $this->actingAs($user)\n        ->putJson(route('comments.update', $comment), $badData)\n        ->assertJsonValidationErrors($errors);\n})->with([\n    [['content' => ''], ['content' => 'The content field is required.']],\n    [['content' => 1], ['content' => 'The content field must be a string.']],\n    [['content' => 'a'], ['content' => 'The content field must be at least 6 characters.']],\n    [['content' => 'a' . str_repeat('a', 2001)], ['content' => 'The content field must not be greater than 2000 characters.']],\n]);\n\nit('returns the comment', function () {\n    $user = User::factory()->create();\n    $comment = Comment::factory()->for($user)->create();\n\n    $this->actingAs($user)\n        ->putJson(route('comments.update', $comment), [\n            'content' => 'Updated content',\n        ])\n        ->assertOk()\n        ->assertJson(\n            fn(AssertableJson $json) => $json\n                ->has(\n                    'data',\n                    fn(AssertableJson $json) => $json\n                        ->where('id', $comment->id)\n                        ->where('content', 'Updated content')\n                        ->has(\n                            'author',\n                            fn(AssertableJson $json) => $json\n                                ->where('name', $user->name)\n                                ->where('username', $user->username)\n                                ->where('avatar', $user->avatar)\n                        )\n                )\n        );\n});\n","tests\u002FHttp\u002FApi\u002FComment\u002FUpdateTest.php",[59,3364,3365,3369,3373,3377,3381,3385,3389,3393,3397,3401,3406,3410,3415,3419,3423,3427,3432,3436,3440,3444,3448,3453,3458,3463,3468,3472,3476,3481,3485,3489,3494,3498,3502,3506,3510,3515,3520,3525,3530,3536,3542,3547,3552,3557,3562,3567,3573,3578,3583,3589,3595,3600,3605,3610,3615,3621,3626,3631,3637,3642,3647,3652,3657,3662,3667,3672,3678,3683,3689,3694,3699,3705,3710,3716,3721,3726,3732,3737,3742,3747,3752,3757,3762],{"__ignoreMap":257},[261,3366,3367],{"class":263,"line":264},[261,3368,598],{},[261,3370,3371],{"class":263,"line":288},[261,3372,454],{"emptyLinePlaceholder":453},[261,3374,3375],{"class":263,"line":316},[261,3376,607],{},[261,3378,3379],{"class":263,"line":347},[261,3380,454],{"emptyLinePlaceholder":453},[261,3382,3383],{"class":263,"line":373},[261,3384,933],{},[261,3386,3387],{"class":263,"line":457},[261,3388,1333],{},[261,3390,3391],{"class":263,"line":463},[261,3392,1603],{},[261,3394,3395],{"class":263,"line":469},[261,3396,454],{"emptyLinePlaceholder":453},[261,3398,3399],{"class":263,"line":474},[261,3400,2616],{},[261,3402,3403],{"class":263,"line":480},[261,3404,3405],{},"    $comment = Comment::factory()->create();\n",[261,3407,3408],{"class":263,"line":486},[261,3409,454],{"emptyLinePlaceholder":453},[261,3411,3412],{"class":263,"line":647},[261,3413,3414],{},"    $this->putJson(route('comments.update', $comment))\n",[261,3416,3417],{"class":263,"line":653},[261,3418,2634],{},[261,3420,3421],{"class":263,"line":659},[261,3422,686],{},[261,3424,3425],{"class":263,"line":665},[261,3426,454],{"emptyLinePlaceholder":453},[261,3428,3429],{"class":263,"line":671},[261,3430,3431],{},"it('requires the user to be the author of the comment', function () {\n",[261,3433,3434],{"class":263,"line":677},[261,3435,2699],{},[261,3437,3438],{"class":263,"line":683},[261,3439,3405],{},[261,3441,3442],{"class":263,"line":993},[261,3443,454],{"emptyLinePlaceholder":453},[261,3445,3446],{"class":263,"line":1171},[261,3447,2712],{},[261,3449,3450],{"class":263,"line":1177},[261,3451,3452],{},"        ->putJson(route('comments.update', $comment), [\n",[261,3454,3455],{"class":263,"line":1182},[261,3456,3457],{},"            'content' => 'Updated content',\n",[261,3459,3460],{"class":263,"line":1478},[261,3461,3462],{},"        ])\n",[261,3464,3465],{"class":263,"line":1483},[261,3466,3467],{},"        ->assertForbidden();\n",[261,3469,3470],{"class":263,"line":1488},[261,3471,686],{},[261,3473,3474],{"class":263,"line":1493},[261,3475,454],{"emptyLinePlaceholder":453},[261,3477,3478],{"class":263,"line":1499},[261,3479,3480],{},"it('updates a comment', function () {\n",[261,3482,3483],{"class":263,"line":1504},[261,3484,2699],{},[261,3486,3487],{"class":263,"line":1509},[261,3488,1346],{},[261,3490,3491],{"class":263,"line":1514},[261,3492,3493],{},"        ->for($user)\n",[261,3495,3496],{"class":263,"line":1520},[261,3497,1306],{},[261,3499,3500],{"class":263,"line":1723},[261,3501,454],{"emptyLinePlaceholder":453},[261,3503,3504],{"class":263,"line":1729},[261,3505,2712],{},[261,3507,3508],{"class":263,"line":1735},[261,3509,3452],{},[261,3511,3513],{"class":263,"line":3512},35,[261,3514,3457],{},[261,3516,3518],{"class":263,"line":3517},36,[261,3519,680],{},[261,3521,3523],{"class":263,"line":3522},37,[261,3524,454],{"emptyLinePlaceholder":453},[261,3526,3528],{"class":263,"line":3527},38,[261,3529,2735],{},[261,3531,3533],{"class":263,"line":3532},39,[261,3534,3535],{},"        'id' => $comment->id,\n",[261,3537,3539],{"class":263,"line":3538},40,[261,3540,3541],{},"        'content' => 'Updated content',\n",[261,3543,3545],{"class":263,"line":3544},41,[261,3546,2755],{},[261,3548,3550],{"class":263,"line":3549},42,[261,3551,686],{},[261,3553,3555],{"class":263,"line":3554},43,[261,3556,454],{"emptyLinePlaceholder":453},[261,3558,3560],{"class":263,"line":3559},44,[261,3561,2845],{},[261,3563,3565],{"class":263,"line":3564},45,[261,3566,2699],{},[261,3568,3570],{"class":263,"line":3569},46,[261,3571,3572],{},"    $comment = Comment::factory()->for($user)->create();\n",[261,3574,3576],{"class":263,"line":3575},47,[261,3577,454],{"emptyLinePlaceholder":453},[261,3579,3581],{"class":263,"line":3580},48,[261,3582,2712],{},[261,3584,3586],{"class":263,"line":3585},49,[261,3587,3588],{},"        ->putJson(route('comments.update', $comment), $badData)\n",[261,3590,3592],{"class":263,"line":3591},50,[261,3593,3594],{},"        ->assertJsonValidationErrors($errors);\n",[261,3596,3598],{"class":263,"line":3597},51,[261,3599,2877],{},[261,3601,3603],{"class":263,"line":3602},52,[261,3604,2882],{},[261,3606,3608],{"class":263,"line":3607},53,[261,3609,2887],{},[261,3611,3613],{"class":263,"line":3612},54,[261,3614,2892],{},[261,3616,3618],{"class":263,"line":3617},55,[261,3619,3620],{},"    [['content' => 'a' . str_repeat('a', 2001)], ['content' => 'The content field must not be greater than 2000 characters.']],\n",[261,3622,3624],{"class":263,"line":3623},56,[261,3625,2902],{},[261,3627,3629],{"class":263,"line":3628},57,[261,3630,454],{"emptyLinePlaceholder":453},[261,3632,3634],{"class":263,"line":3633},58,[261,3635,3636],{},"it('returns the comment', function () {\n",[261,3638,3640],{"class":263,"line":3639},59,[261,3641,2699],{},[261,3643,3645],{"class":263,"line":3644},60,[261,3646,3572],{},[261,3648,3650],{"class":263,"line":3649},61,[261,3651,454],{"emptyLinePlaceholder":453},[261,3653,3655],{"class":263,"line":3654},62,[261,3656,2712],{},[261,3658,3660],{"class":263,"line":3659},63,[261,3661,3452],{},[261,3663,3665],{"class":263,"line":3664},64,[261,3666,3457],{},[261,3668,3670],{"class":263,"line":3669},65,[261,3671,3462],{},[261,3673,3675],{"class":263,"line":3674},66,[261,3676,3677],{},"        ->assertOk()\n",[261,3679,3681],{"class":263,"line":3680},67,[261,3682,1650],{},[261,3684,3686],{"class":263,"line":3685},68,[261,3687,3688],{},"            fn(AssertableJson $json) => $json\n",[261,3690,3692],{"class":263,"line":3691},69,[261,3693,1660],{},[261,3695,3697],{"class":263,"line":3696},70,[261,3698,1665],{},[261,3700,3702],{"class":263,"line":3701},71,[261,3703,3704],{},"                    fn(AssertableJson $json) => $json\n",[261,3706,3708],{"class":263,"line":3707},72,[261,3709,3172],{},[261,3711,3713],{"class":263,"line":3712},73,[261,3714,3715],{},"                        ->where('content', 'Updated content')\n",[261,3717,3719],{"class":263,"line":3718},74,[261,3720,1690],{},[261,3722,3724],{"class":263,"line":3723},75,[261,3725,1695],{},[261,3727,3729],{"class":263,"line":3728},76,[261,3730,3731],{},"                            fn(AssertableJson $json) => $json\n",[261,3733,3735],{"class":263,"line":3734},77,[261,3736,3194],{},[261,3738,3740],{"class":263,"line":3739},78,[261,3741,3199],{},[261,3743,3745],{"class":263,"line":3744},79,[261,3746,3204],{},[261,3748,3750],{"class":263,"line":3749},80,[261,3751,1720],{},[261,3753,3755],{"class":263,"line":3754},81,[261,3756,1726],{},[261,3758,3760],{"class":263,"line":3759},82,[261,3761,1732],{},[261,3763,3765],{"class":263,"line":3764},83,[261,3766,686],{},[10,3768,3769],{},"Ajoutons ensuite la route :",[251,3771,3773],{"className":424,"code":3772,"filename":379,"language":268,"meta":257,"style":257},"\u003C?php\n\nuse App\\Http\\Controllers\\Api\\CommentController; \u002F\u002F [!code ++]\n\nRoute::middleware('auth')->group(function () {\n    Route::put('\u002Fcomments\u002F{comment}', [CommentController::class, 'update']) \u002F\u002F [!code ++]\n        ->name('comments.update'); \u002F\u002F [!code ++]\n});\n",[59,3774,3775,3779,3783,3788,3792,3796,3801,3806],{"__ignoreMap":257},[261,3776,3777],{"class":263,"line":264},[261,3778,598],{},[261,3780,3781],{"class":263,"line":288},[261,3782,454],{"emptyLinePlaceholder":453},[261,3784,3785],{"class":263,"line":316},[261,3786,3787],{},"use App\\Http\\Controllers\\Api\\CommentController; \u002F\u002F [!code ++]\n",[261,3789,3790],{"class":263,"line":347},[261,3791,454],{"emptyLinePlaceholder":453},[261,3793,3794],{"class":263,"line":373},[261,3795,2651],{},[261,3797,3798],{"class":263,"line":457},[261,3799,3800],{},"    Route::put('\u002Fcomments\u002F{comment}', [CommentController::class, 'update']) \u002F\u002F [!code ++]\n",[261,3802,3803],{"class":263,"line":463},[261,3804,3805],{},"        ->name('comments.update'); \u002F\u002F [!code ++]\n",[261,3807,3808],{"class":263,"line":469},[261,3809,686],{},[10,3811,3812],{},"Créons le contrôleur :",[251,3814,3815],{"className":253,"code":330,"filename":255,"language":256,"meta":257,"style":257},[59,3816,3817],{"__ignoreMap":257},[261,3818,3819,3821,3823,3825],{"class":263,"line":264},[261,3820,268],{"class":267},[261,3822,272],{"class":271},[261,3824,341],{"class":271},[261,3826,344],{"class":271},[10,3828,3829,3830,708],{},"Implémentons la méthode ",[59,3831,3832],{},"update",[251,3834,3837],{"className":424,"code":3835,"filename":3836,"language":268,"meta":257,"style":257},"\u003C?php\n\ndeclare(strict_types=1);\n\nnamespace App\\Http\\Controllers\\Api;\n\nuse App\\Http\\Controllers\\Controller;\nuse App\\Http\\Requests\\UpdateCommentRequest;\nuse App\\Http\\Resources\\CommentResource;\nuse App\\Models\\Comment;\nuse Illuminate\\Http\\Resources\\Json\\JsonResource;\n\nfinal class CommentController extends Controller\n{\n    public function update(UpdateCommentRequest $request, Comment $comment): JsonResource\n    {\n        $comment->update($request->validated());\n        $comment->load('user');\n\n        return CommentResource::make($comment);\n    }\n}\n","app\u002FHttp\u002FApi\u002FCommentController.php",[59,3838,3839,3843,3847,3851,3855,3859,3863,3867,3872,3876,3880,3884,3888,3893,3897,3902,3906,3911,3916,3920,3925,3929],{"__ignoreMap":257},[261,3840,3841],{"class":263,"line":264},[261,3842,598],{},[261,3844,3845],{"class":263,"line":288},[261,3846,454],{"emptyLinePlaceholder":453},[261,3848,3849],{"class":263,"line":316},[261,3850,607],{},[261,3852,3853],{"class":263,"line":347},[261,3854,454],{"emptyLinePlaceholder":453},[261,3856,3857],{"class":263,"line":373},[261,3858,1932],{},[261,3860,3861],{"class":263,"line":457},[261,3862,454],{"emptyLinePlaceholder":453},[261,3864,3865],{"class":263,"line":463},[261,3866,1941],{},[261,3868,3869],{"class":263,"line":469},[261,3870,3871],{},"use App\\Http\\Requests\\UpdateCommentRequest;\n",[261,3873,3874],{"class":263,"line":474},[261,3875,2025],{},[261,3877,3878],{"class":263,"line":480},[261,3879,933],{},[261,3881,3882],{"class":263,"line":486},[261,3883,2168],{},[261,3885,3886],{"class":263,"line":647},[261,3887,454],{"emptyLinePlaceholder":453},[261,3889,3890],{"class":263,"line":653},[261,3891,3892],{},"final class CommentController extends Controller\n",[261,3894,3895],{"class":263,"line":659},[261,3896,438],{},[261,3898,3899],{"class":263,"line":665},[261,3900,3901],{},"    public function update(UpdateCommentRequest $request, Comment $comment): JsonResource\n",[261,3903,3904],{"class":263,"line":671},[261,3905,518],{},[261,3907,3908],{"class":263,"line":677},[261,3909,3910],{},"        $comment->update($request->validated());\n",[261,3912,3913],{"class":263,"line":683},[261,3914,3915],{},"        $comment->load('user');\n",[261,3917,3918],{"class":263,"line":993},[261,3919,454],{"emptyLinePlaceholder":453},[261,3921,3922],{"class":263,"line":1171},[261,3923,3924],{},"        return CommentResource::make($comment);\n",[261,3926,3927],{"class":263,"line":1177},[261,3928,547],{},[261,3930,3931],{"class":263,"line":1182},[261,3932,552],{},[10,3934,3935],{},"Cette méthode a besoin d'une form request dédiée :",[251,3937,3939],{"className":253,"code":3938,"filename":255,"language":256,"meta":257,"style":257},"php artisan make:request UpdateCommentRequest\n",[59,3940,3941],{"__ignoreMap":257},[261,3942,3943,3945,3947,3949],{"class":263,"line":264},[261,3944,268],{"class":267},[261,3946,272],{"class":271},[261,3948,2926],{"class":271},[261,3950,3951],{"class":271}," UpdateCommentRequest\n",[10,3953,3954],{},"Implémentons cette requête :",[251,3956,3959],{"className":424,"code":3957,"filename":3958,"language":268,"meta":257,"style":257},"\u003C?php\n\ndeclare(strict_types=1);\n\nnamespace App\\Http\\Requests;\n\nuse App\\Models\\Comment;\nuse Illuminate\\Foundation\\Http\\FormRequest;\n\n\u002F**\n * @property Comment $comment\n *\u002F\nfinal class UpdateCommentRequest extends FormRequest\n{\n    \u002F**\n     * Determine if the user is authorized to make this request.\n     *\u002F\n    public function authorize(): bool\n    {\n        return $this->user()->can('update', $this->comment);\n    }\n\n    \u002F**\n     * Get the validation rules that apply to the request.\n     *\n     * @return array\u003Cstring, \\Illuminate\\Contracts\\Validation\\ValidationRule|array\u003Cmixed>|string>\n     *\u002F\n    public function rules(): array\n    {\n        return [\n            'content' => ['required', 'string', 'max:2000', 'min:6'],\n        ];\n    }\n}\n","app\u002FHttp\u002FRequests\u002FUpdateCommentRequest.php",[59,3960,3961,3965,3969,3973,3977,3981,3985,3989,3993,3997,4001,4006,4010,4015,4019,4023,4028,4032,4037,4041,4046,4050,4054,4058,4062,4066,4070,4074,4078,4082,4086,4090,4094,4098],{"__ignoreMap":257},[261,3962,3963],{"class":263,"line":264},[261,3964,598],{},[261,3966,3967],{"class":263,"line":288},[261,3968,454],{"emptyLinePlaceholder":453},[261,3970,3971],{"class":263,"line":316},[261,3972,607],{},[261,3974,3975],{"class":263,"line":347},[261,3976,454],{"emptyLinePlaceholder":453},[261,3978,3979],{"class":263,"line":373},[261,3980,2948],{},[261,3982,3983],{"class":263,"line":457},[261,3984,454],{"emptyLinePlaceholder":453},[261,3986,3987],{"class":263,"line":463},[261,3988,933],{},[261,3990,3991],{"class":263,"line":469},[261,3992,2957],{},[261,3994,3995],{"class":263,"line":474},[261,3996,454],{"emptyLinePlaceholder":453},[261,3998,3999],{"class":263,"line":480},[261,4000,2177],{},[261,4002,4003],{"class":263,"line":486},[261,4004,4005],{}," * @property Comment $comment\n",[261,4007,4008],{"class":263,"line":647},[261,4009,2187],{},[261,4011,4012],{"class":263,"line":653},[261,4013,4014],{},"final class UpdateCommentRequest extends FormRequest\n",[261,4016,4017],{"class":263,"line":659},[261,4018,438],{},[261,4020,4021],{"class":263,"line":665},[261,4022,1036],{},[261,4024,4025],{"class":263,"line":671},[261,4026,4027],{},"     * Determine if the user is authorized to make this request.\n",[261,4029,4030],{"class":263,"line":677},[261,4031,1056],{},[261,4033,4034],{"class":263,"line":683},[261,4035,4036],{},"    public function authorize(): bool\n",[261,4038,4039],{"class":263,"line":993},[261,4040,518],{},[261,4042,4043],{"class":263,"line":1171},[261,4044,4045],{},"        return $this->user()->can('update', $this->comment);\n",[261,4047,4048],{"class":263,"line":1177},[261,4049,547],{},[261,4051,4052],{"class":263,"line":1182},[261,4053,454],{"emptyLinePlaceholder":453},[261,4055,4056],{"class":263,"line":1478},[261,4057,1036],{},[261,4059,4060],{"class":263,"line":1483},[261,4061,2979],{},[261,4063,4064],{"class":263,"line":1488},[261,4065,1046],{},[261,4067,4068],{"class":263,"line":1493},[261,4069,2988],{},[261,4071,4072],{"class":263,"line":1499},[261,4073,1056],{},[261,4075,4076],{"class":263,"line":1504},[261,4077,2997],{},[261,4079,4080],{"class":263,"line":1509},[261,4081,518],{},[261,4083,4084],{"class":263,"line":1514},[261,4085,523],{},[261,4087,4088],{"class":263,"line":1520},[261,4089,3010],{},[261,4091,4092],{"class":263,"line":1723},[261,4093,542],{},[261,4095,4096],{"class":263,"line":1729},[261,4097,547],{},[261,4099,4100],{"class":263,"line":1735},[261,4101,552],{},[10,4103,2091,4104,4107],{},[59,4105,4106],{},"authorize"," de la requête vérifie si l'utilisateur courant peut modifier le commentaire. Elle délègue cette décision à une policy, que nous devons créer.",[251,4109,4111],{"className":253,"code":4110,"filename":255,"language":256,"meta":257,"style":257},"php artisan make:policy CommentPolicy\n",[59,4112,4113],{"__ignoreMap":257},[261,4114,4115,4117,4119,4122],{"class":263,"line":264},[261,4116,268],{"class":267},[261,4118,272],{"class":271},[261,4120,4121],{"class":271}," make:policy",[261,4123,4124],{"class":271}," CommentPolicy\n",[10,4126,4127],{},"Implémentons ensuite la policy :",[251,4129,4132],{"className":424,"code":4130,"filename":4131,"language":268,"meta":257,"style":257},"\u003C?php\n\nnamespace App\\Policies;\n\nuse App\\Models\\Comment;\nuse App\\Models\\User;\n\nclass CommentPolicy\n{\n    \u002F**\n     * Determine whether the user can update the model.\n     *\u002F\n    public function update(User $user, Comment $comment): bool\n    {\n        return $user->id === $comment->user_id;\n    }\n}\n","app\u002FPolicies\u002FCommentPolicy.php",[59,4133,4134,4138,4142,4147,4151,4155,4159,4163,4168,4172,4176,4181,4185,4190,4194,4199,4203],{"__ignoreMap":257},[261,4135,4136],{"class":263,"line":264},[261,4137,598],{},[261,4139,4140],{"class":263,"line":288},[261,4141,454],{"emptyLinePlaceholder":453},[261,4143,4144],{"class":263,"line":316},[261,4145,4146],{},"namespace App\\Policies;\n",[261,4148,4149],{"class":263,"line":347},[261,4150,454],{"emptyLinePlaceholder":453},[261,4152,4153],{"class":263,"line":373},[261,4154,933],{},[261,4156,4157],{"class":263,"line":457},[261,4158,1333],{},[261,4160,4161],{"class":263,"line":463},[261,4162,454],{"emptyLinePlaceholder":453},[261,4164,4165],{"class":263,"line":469},[261,4166,4167],{},"class CommentPolicy\n",[261,4169,4170],{"class":263,"line":474},[261,4171,438],{},[261,4173,4174],{"class":263,"line":480},[261,4175,1036],{},[261,4177,4178],{"class":263,"line":486},[261,4179,4180],{},"     * Determine whether the user can update the model.\n",[261,4182,4183],{"class":263,"line":647},[261,4184,1056],{},[261,4186,4187],{"class":263,"line":653},[261,4188,4189],{},"    public function update(User $user, Comment $comment): bool\n",[261,4191,4192],{"class":263,"line":659},[261,4193,518],{},[261,4195,4196],{"class":263,"line":665},[261,4197,4198],{},"        return $user->id === $comment->user_id;\n",[261,4200,4201],{"class":263,"line":671},[261,4202,547],{},[261,4204,4205],{"class":263,"line":677},[261,4206,552],{},[10,4208,4209],{},"Le flux de modification est maintenant terminé.",[10,4211,4212],{},"Terminons l'article en ajoutant la suppression d'un commentaire :",[251,4214,4217],{"className":424,"code":4215,"filename":4216,"language":268,"meta":257,"style":257},"\u003C?php\n\ndeclare(strict_types=1);\n\nuse App\\Models\\Comment;\nuse App\\Models\\User;\n\nit('requires authentification', function () {\n    $comment = Comment::factory()->create();\n\n    $this->deleteJson(route('comments.destroy', $comment))\n        ->assertUnauthorized();\n});\n\nit('requires the user to be the author of the comment', function () {\n    $user = User::factory()->create();\n    $comment = Comment::factory()->create();\n\n    $this->actingAs($user)\n        ->deleteJson(route('comments.destroy', $comment))\n        ->assertForbidden();\n});\n\nit('deletes a comment', function () {\n    $user = User::factory()->create();\n    $comment = Comment::factory()->for($user)->create();\n\n    $this->actingAs($user)\n        ->deleteJson(route('comments.destroy', $comment));\n\n    $this->assertDatabaseMissing('comments', [\n        'id' => $comment->id,\n    ]);\n});\n","tests\u002FHttp\u002FApi\u002FComment\u002FDestroyTest.php",[59,4218,4219,4223,4227,4231,4235,4239,4243,4247,4252,4256,4260,4265,4269,4273,4277,4281,4285,4289,4293,4297,4302,4306,4310,4314,4319,4323,4327,4331,4335,4340,4344,4349,4353,4357],{"__ignoreMap":257},[261,4220,4221],{"class":263,"line":264},[261,4222,598],{},[261,4224,4225],{"class":263,"line":288},[261,4226,454],{"emptyLinePlaceholder":453},[261,4228,4229],{"class":263,"line":316},[261,4230,607],{},[261,4232,4233],{"class":263,"line":347},[261,4234,454],{"emptyLinePlaceholder":453},[261,4236,4237],{"class":263,"line":373},[261,4238,933],{},[261,4240,4241],{"class":263,"line":457},[261,4242,1333],{},[261,4244,4245],{"class":263,"line":463},[261,4246,454],{"emptyLinePlaceholder":453},[261,4248,4249],{"class":263,"line":469},[261,4250,4251],{},"it('requires authentification', function () {\n",[261,4253,4254],{"class":263,"line":474},[261,4255,3405],{},[261,4257,4258],{"class":263,"line":480},[261,4259,454],{"emptyLinePlaceholder":453},[261,4261,4262],{"class":263,"line":486},[261,4263,4264],{},"    $this->deleteJson(route('comments.destroy', $comment))\n",[261,4266,4267],{"class":263,"line":647},[261,4268,2634],{},[261,4270,4271],{"class":263,"line":653},[261,4272,686],{},[261,4274,4275],{"class":263,"line":659},[261,4276,454],{"emptyLinePlaceholder":453},[261,4278,4279],{"class":263,"line":665},[261,4280,3431],{},[261,4282,4283],{"class":263,"line":671},[261,4284,2699],{},[261,4286,4287],{"class":263,"line":677},[261,4288,3405],{},[261,4290,4291],{"class":263,"line":683},[261,4292,454],{"emptyLinePlaceholder":453},[261,4294,4295],{"class":263,"line":993},[261,4296,2712],{},[261,4298,4299],{"class":263,"line":1171},[261,4300,4301],{},"        ->deleteJson(route('comments.destroy', $comment))\n",[261,4303,4304],{"class":263,"line":1177},[261,4305,3467],{},[261,4307,4308],{"class":263,"line":1182},[261,4309,686],{},[261,4311,4312],{"class":263,"line":1478},[261,4313,454],{"emptyLinePlaceholder":453},[261,4315,4316],{"class":263,"line":1483},[261,4317,4318],{},"it('deletes a comment', function () {\n",[261,4320,4321],{"class":263,"line":1488},[261,4322,2699],{},[261,4324,4325],{"class":263,"line":1493},[261,4326,3572],{},[261,4328,4329],{"class":263,"line":1499},[261,4330,454],{"emptyLinePlaceholder":453},[261,4332,4333],{"class":263,"line":1504},[261,4334,2712],{},[261,4336,4337],{"class":263,"line":1509},[261,4338,4339],{},"        ->deleteJson(route('comments.destroy', $comment));\n",[261,4341,4342],{"class":263,"line":1514},[261,4343,454],{"emptyLinePlaceholder":453},[261,4345,4346],{"class":263,"line":1520},[261,4347,4348],{},"    $this->assertDatabaseMissing('comments', [\n",[261,4350,4351],{"class":263,"line":1723},[261,4352,3535],{},[261,4354,4355],{"class":263,"line":1729},[261,4356,2755],{},[261,4358,4359],{"class":263,"line":1735},[261,4360,686],{},[251,4362,4364],{"className":424,"code":4363,"filename":379,"language":268,"meta":257,"style":257},"\u003C?php\n\n\u002F\u002F ...\n\nRoute::middleware('auth')->group(function () {\n    \u002F\u002F ...\n\n    Route::delete('\u002Fcomments\u002F{comment}', [CommentController::class, 'destroy'])\n        ->name('comments.destroy');\n});\n\n",[59,4365,4366,4370,4374,4378,4382,4386,4391,4395,4400,4405],{"__ignoreMap":257},[261,4367,4368],{"class":263,"line":264},[261,4369,598],{},[261,4371,4372],{"class":263,"line":288},[261,4373,454],{"emptyLinePlaceholder":453},[261,4375,4376],{"class":263,"line":316},[261,4377,852],{},[261,4379,4380],{"class":263,"line":347},[261,4381,454],{"emptyLinePlaceholder":453},[261,4383,4384],{"class":263,"line":373},[261,4385,2651],{},[261,4387,4388],{"class":263,"line":457},[261,4389,4390],{},"    \u002F\u002F ...\n",[261,4392,4393],{"class":263,"line":463},[261,4394,454],{"emptyLinePlaceholder":453},[261,4396,4397],{"class":263,"line":469},[261,4398,4399],{},"    Route::delete('\u002Fcomments\u002F{comment}', [CommentController::class, 'destroy'])\n",[261,4401,4402],{"class":263,"line":474},[261,4403,4404],{},"        ->name('comments.destroy');\n",[261,4406,4407],{"class":263,"line":480},[261,4408,686],{},[251,4410,4412],{"className":424,"code":4411,"filename":3836,"language":268,"meta":257,"style":257},"use Illuminate\\Http\\Response;\nuse Illuminate\\Support\\Facades\\Gate;\n\nfinal class CommentController extends Controller\n{\n    \u002F\u002F ...\n\n    public function destroy(Comment $comment): Response\n    {\n        Gate::authorize('delete', $comment);\n\n        $comment->delete();\n\n        return response()->noContent();\n    }\n}\n",[59,4413,4414,4419,4424,4428,4432,4436,4440,4444,4449,4453,4458,4462,4467,4471,4476,4480],{"__ignoreMap":257},[261,4415,4416],{"class":263,"line":264},[261,4417,4418],{},"use Illuminate\\Http\\Response;\n",[261,4420,4421],{"class":263,"line":288},[261,4422,4423],{},"use Illuminate\\Support\\Facades\\Gate;\n",[261,4425,4426],{"class":263,"line":316},[261,4427,454],{"emptyLinePlaceholder":453},[261,4429,4430],{"class":263,"line":347},[261,4431,3892],{},[261,4433,4434],{"class":263,"line":373},[261,4435,438],{},[261,4437,4438],{"class":263,"line":457},[261,4439,4390],{},[261,4441,4442],{"class":263,"line":463},[261,4443,454],{"emptyLinePlaceholder":453},[261,4445,4446],{"class":263,"line":469},[261,4447,4448],{},"    public function destroy(Comment $comment): Response\n",[261,4450,4451],{"class":263,"line":474},[261,4452,518],{},[261,4454,4455],{"class":263,"line":480},[261,4456,4457],{},"        Gate::authorize('delete', $comment);\n",[261,4459,4460],{"class":263,"line":486},[261,4461,454],{"emptyLinePlaceholder":453},[261,4463,4464],{"class":263,"line":647},[261,4465,4466],{},"        $comment->delete();\n",[261,4468,4469],{"class":263,"line":653},[261,4470,454],{"emptyLinePlaceholder":453},[261,4472,4473],{"class":263,"line":659},[261,4474,4475],{},"        return response()->noContent();\n",[261,4477,4478],{"class":263,"line":665},[261,4479,547],{},[261,4481,4482],{"class":263,"line":671},[261,4483,552],{},[10,4485,4486,4487,4490,4491,4494,4495,327],{},"La façade ",[59,4488,4489],{},"Gate"," autorise la suppression. Laravel résout ",[59,4492,4493],{},"CommentPolicy"," à partir du modèle transmis à ",[59,4496,4106],{},[251,4498,4500],{"className":424,"code":4499,"filename":4131,"language":268,"meta":257,"style":257},"final class CommentPolicy\n{\n    \u002F\u002F ...\n\n    \u002F**\n     * Determine whether the user can delete the model.\n     *\u002F\n    public function delete(User $user, Comment $comment): bool\n    {\n        return $user->id === $comment->user_id;\n    }\n}\n",[59,4501,4502,4507,4511,4515,4519,4523,4528,4532,4537,4541,4545,4549],{"__ignoreMap":257},[261,4503,4504],{"class":263,"line":264},[261,4505,4506],{},"final class CommentPolicy\n",[261,4508,4509],{"class":263,"line":288},[261,4510,438],{},[261,4512,4513],{"class":263,"line":316},[261,4514,4390],{},[261,4516,4517],{"class":263,"line":347},[261,4518,454],{"emptyLinePlaceholder":453},[261,4520,4521],{"class":263,"line":373},[261,4522,1036],{},[261,4524,4525],{"class":263,"line":457},[261,4526,4527],{},"     * Determine whether the user can delete the model.\n",[261,4529,4530],{"class":263,"line":463},[261,4531,1056],{},[261,4533,4534],{"class":263,"line":469},[261,4535,4536],{},"    public function delete(User $user, Comment $comment): bool\n",[261,4538,4539],{"class":263,"line":474},[261,4540,518],{},[261,4542,4543],{"class":263,"line":480},[261,4544,4198],{},[261,4546,4547],{"class":263,"line":486},[261,4548,547],{},[261,4550,4551],{"class":263,"line":647},[261,4552,552],{},[10,4554,4555],{},"Le système de commentaires est prêt et les tests nous donnent confiance dans ses principaux comportements sans nécessiter de tout vérifier manuellement.",[44,4557,4559],{"id":4558},"et-maintenant","Et maintenant ?",[10,4561,4562],{},"L'API de commentaires est maintenant en place. Elle permet de lister, créer, modifier et supprimer des commentaires, tandis que les tests décrivent les comportements et les permissions qui protègent ces opérations.",[10,4564,4565],{},"Le développement piloté par les tests a permis de rester concentré : chaque échec indiquait le comportement à ajouter, et les tests terminés nous protègent désormais contre les régressions.",[10,4567,4568,4569,327],{},"Ensuite, nous connecterons le front-end statique au back-end. Nous générerons les métadonnées des articles pendant le build VitePress et utiliserons Laravel pour synchroniser automatiquement la table ",[59,4570,4571],{},"posts",[4573,4574,4575],"style",{},"html pre.shiki code .snPdu, html code.shiki .snPdu{--shiki-light:#6F42C1;--shiki-default:#6F42C1;--shiki-dark:#B392F0}html pre.shiki code .sIIMD, html code.shiki .sIIMD{--shiki-light:#032F62;--shiki-default:#032F62;--shiki-dark:#9ECBFF}html pre.shiki code .sBjJW, html code.shiki .sBjJW{--shiki-light:#005CC5;--shiki-default:#005CC5;--shiki-dark:#79B8FF}html .light .shiki span {color: var(--shiki-light);background: var(--shiki-light-bg);font-style: var(--shiki-light-font-style);font-weight: var(--shiki-light-font-weight);text-decoration: var(--shiki-light-text-decoration);}html.light .shiki span {color: var(--shiki-light);background: var(--shiki-light-bg);font-style: var(--shiki-light-font-style);font-weight: var(--shiki-light-font-weight);text-decoration: var(--shiki-light-text-decoration);}html .default .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html.dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html pre.shiki code .sxrX7, html code.shiki .sxrX7{--shiki-light:#24292E;--shiki-default:#24292E;--shiki-dark:#E1E4E8}",{"title":257,"searchDepth":288,"depth":288,"links":4577},[4578,4581,4582,4583,4584],{"id":46,"depth":288,"text":47,"children":4579},[4580],{"id":236,"depth":316,"text":237},{"id":393,"depth":288,"text":394},{"id":1534,"depth":288,"text":1535},{"id":3322,"depth":288,"text":3323},{"id":4558,"depth":288,"text":4559},"f41b79a9-943b-4d03-a926-cf461f7bf58a","2025-02-25","Construisez une API de commentaires Laravel avec des modèles, migrations, ressources, policies, form requests, contrôleurs et tests complets.","md",null,{},"\u002Ffr\u002Fseries\u002Fempower-and-dynamize-our-vitepress-blog-with-a-laravel-api\u002Fbuilding-a-simple-comment-system-for-user-engagement","---\ncontentId: f41b79a9-943b-4d03-a926-cf461f7bf58a\npart: 4\ntitle: Construire un système simple de commentaires Laravel\ndescription: Construisez une API de commentaires Laravel avec des modèles, migrations, ressources, policies, form requests, contrôleurs et tests complets.\ndate: 2025-02-25\nseriesSlug: empower-and-dynamize-our-vitepress-blog-with-a-laravel-api\n---\n\nL'authentification GitHub est en place. Nous pouvons maintenant construire la fonctionnalité qu'elle rend possible : les commentaires.\n\nAvant d'écrire du code, définissons la première version du système de commentaires. Nous voulons prendre en charge les interactions essentielles sans ajouter plus de complexité que nécessaire :\n\n- Les utilisateurs doivent pouvoir laisser des commentaires sur les articles.\n- Les utilisateurs doivent pouvoir modifier ou supprimer leurs commentaires.\n- Les réponses aux commentaires ne sont pas prévues.\n- La prise en charge du Markdown n'est pas prévue.\n\nPour l'instant, nous voulons un système de commentaires volontairement simple.\n\n::callout{icon=\"i-ph-info-duotone\" color=\"info\"}\nJe souhaite garder le code simple pour deux raisons. D'abord, le processus et les décisions qui le sous-tendent sont plus importants que la quantité de code. Ensuite, des fonctionnalités plus avancées pourront être explorées dans une future série.\n::\n\n## Construire le système de commentaires\n\nMaintenant que les exigences sont claires, mettons-les en relation avec les concepts de notre application.\n\nUn commentaire est un message laissé par un utilisateur sur un article. Dans notre système, le modèle possédera les propriétés suivantes :\n\n- `id` : L'identifiant unique du commentaire.\n- `post_id` : L'identifiant de l'article auquel le commentaire appartient.\n- `user_id` : L'identifiant de l'utilisateur qui a laissé le commentaire.\n- `content` : Le contenu du commentaire.\n- `created_at` : La date et l'heure de création du commentaire.\n- `updated_at` : La date et l'heure de sa dernière modification.\n\n`user_id` référence la table `users`, et le modèle `User` possédera une relation `comments`. Qu'en est-il de `post_id` ?\n\nPour `post_id`, nous avons besoin d'un modèle `Post` avec les propriétés suivantes :\n\n- `id` : L'identifiant unique de l'article.\n- `meta_id` : L'identifiant unique provenant du front-end.\n- `title` : Le titre de l'article.\n- `created_at` : La date et l'heure de création de l'article.\n- `updated_at` : La date et l'heure de sa dernière modification.\n\nLe modèle `Post` possédera une relation `comments`, ce qui nous permettra d'associer plusieurs commentaires à chaque article. Nous parlerons de `meta_id` dans l'article suivant, vous pouvez donc ignorer son rôle pour le moment.\n\nLes relations ressembleront à ceci :\n\n\u003C!-- TODO: add a drawsql image -->\n\nUne fois les modèles et les relations définis, nous pouvons concevoir l'API qui permettra de récupérer, créer, modifier et supprimer les commentaires.\n\nCommençons par lister les endpoints nécessaires :\n\n- Lister tous les commentaires d'un article, quelle que soit leur origine\n- Créer un commentaire avec un utilisateur authentifié\n- Modifier un commentaire avec l'utilisateur qui l'a créé\n- Supprimer un commentaire avec l'utilisateur qui l'a créé\n\nAssocions ensuite les endpoints aux routes :\n\n- `GET    \u002Fposts\u002F{post}\u002Fcomments` : Lister tous les commentaires d'un article\n- `POST   \u002Fposts\u002F{post}\u002Fcomments` : Créer un commentaire\n- `PUT    \u002Fcomments\u002F{comment}` : Modifier un commentaire\n- `DELETE \u002Fcomments\u002F{comment}` : Supprimer un commentaire\n\nL'association est simple. Pourquoi utiliser `\u002Fcomments\u002F{comment}` plutôt que `\u002Fposts\u002F{post}\u002Fcomments\u002F{comment}` pour les deux dernières routes ? L'identifiant d'un commentaire est unique, il permet donc de l'identifier sans répéter celui de l'article. Dans Laravel, on appelle cela le [shallow nesting](https:\u002F\u002Flaravel.com\u002Fdocs\u002F12.x\u002Fcontrollers#shallow-nesting), ou imbrication superficielle.\n\n### Résumé avant d'écrire le code\n\nAvant de commencer à coder, résumons les étapes d'implémentation :\n\n1. Créer un modèle `Post` avec sa migration.\n\n```bash [terminal]\nphp artisan make:model Post -m -f\n```\n\n2. Créer un modèle `Comment` avec sa migration.\n\n```bash [terminal]\nphp artisan make:model Comment -m -f\n```\n\n3. Créer un `CommentController` dans `app\u002FHttp\u002FApi`.\n\n```bash [terminal]\nphp artisan make:controller Api\u002FCommentController\n```\n\n4. Créer un `PostCommentController` dans `app\u002FHttp\u002FApi`.\n\n```bash [terminal]\nphp artisan make:controller Api\u002FPostCommentController\n```\n\n5. Ajouter les routes à `routes\u002Fapi.php`.\n\nNous ajouterons les tests au fur et à mesure.\n\n::callout{icon=\"i-ph-info-duotone\" color=\"info\"}\nJe n'expliquerai pas chaque test en détail. Je me concentrerai sur les plus importants.\n::\n\nPrêt ? C'est parti !\n\n## Consulter et créer des commentaires\n\nCréez le modèle `Post` avec Artisan :\n\n```bash [terminal]\nphp artisan make:model Post -m -f\n```\n\nOuvrons maintenant le fichier de migration et ajoutons le code suivant :\n\n```php [database\u002Fmigrations\u002F2025_03_02_121249_create_posts_table.php]\nreturn new class extends Migration\n{\n    Schema::create('posts', function (Blueprint $table) {\n        $table->id();\n\n        $table->string('title'); \u002F\u002F [!code ++]\n        $table->unsignedInteger('meta_id')->unique(); \u002F\u002F [!code ++]\n\n        $table->timestamps();\n    });\n};\n```\n\nMettez à jour la factory pour qu'elle corresponde à la migration :\n\n```php [database\u002Ffactories\u002FPostFactory.php]\nclass PostFactory extends Factory\n{\n    public function definition(): array\n    {\n        return [\n            'title' => fake()->sentence(), \u002F\u002F [!code ++]\n            'meta_id' => fake()->unique()->numberBetween(1, 1000), \u002F\u002F [!code ++]\n        ];\n    }\n}\n```\n\nAjoutons un test pour vérifier que le modèle possède la forme attendue.\n\nCommençons par créer le fichier de test :\n\n```bash [terminal]\nmkdir -p tests\u002FUnit\u002FModels && touch tests\u002FUnit\u002FModels\u002FPostTest.php\n```\n\nPuis ajoutons le code suivant :\n\n```php [tests\u002FUnit\u002FModels\u002FPostTest.php]\n\u003C?php\n\ndeclare(strict_types=1);\n\nuse App\\Models\\Post;\n\ntest('to array', function () {\n    $post = Post::factory()->create()->fresh();\n\n    expect(array_keys($post->toArray()))\n        ->toEqual([\n            'id',\n            'title',\n            'meta_id',\n            'created_at',\n            'updated_at',\n        ]);\n});\n```\n\nCe test minimal vérifie les propriétés persistées du modèle. Il peut détecter la suppression ou l'ajout accidentel d'une colonne dans une migration. Nous ajouterons un test similaire pour chaque modèle créé.\n\nPour vérifier que le test fonctionne, le dossier `tests\u002FUnit` doit avoir accès à une base de données fonctionnelle. Ajoutons `Unit` à la méthode `in` du fichier `tests\u002FPest.php` :\n\n```php [tests\u002FPest.php]\npest()->extend(Tests\\TestCase::class)\n    ->use(Illuminate\\Foundation\\Testing\\RefreshDatabase::class)\n    ->in('Http', 'Unit');\n```\n\nCréons le modèle `Comment` de la même manière :\n\n```bash [terminal]\nphp artisan make:model Comment -m -f\n```\n\nMettez à jour sa migration :\n\n```php [database\u002Fmigrations\u002F2025_03_02_121249_create_comments_table.php]\nuse App\\Models\\Post; \u002F\u002F [!code ++]\nuse App\\Models\\User; \u002F\u002F [!code ++]\n\nreturn new class extends Migration\n{\n    Schema::create('comments', function (Blueprint $table) {\n        $table->id();\n\n        $table->foreignIdFor(Post::class)->constrained()->cascadeOnDelete(); \u002F\u002F [!code ++]\n        $table->foreignIdFor(User::class)->constrained()->cascadeOnDelete(); \u002F\u002F [!code ++]\n        $table->text('content'); \u002F\u002F [!code ++]\n\n        $table->timestamps();\n    });\n};\n```\n\nMettez à jour la factory pour qu'elle corresponde à la migration :\n\n```php [database\u002Ffactories\u002FCommentFactory.php]\nuse App\\Models\\Post; \u002F\u002F [!code ++]\nuse App\\Models\\User; \u002F\u002F [!code ++]\n\n\u002F\u002F ...\nclass CommentFactory extends Factory\n{\n    public function definition(): array\n    {\n        return [\n            'post_id' => Post::factory(), \u002F\u002F [!code ++]\n            'user_id' => User::factory(), \u002F\u002F [!code ++]\n            'content' => fake()->paragraph(), \u002F\u002F [!code ++]\n        ];\n    }\n}\n```\n\nAjoutez le test correspondant :\n\n```php [tests\u002FUnit\u002FModels\u002FCommentTest.php]\n\u003C?php\n\ndeclare(strict_types=1);\n\nuse App\\Models\\Comment;\n\ntest('to array', function () {\n    $comment = Comment::factory()->create()->fresh();\n\n    expect(array_keys($comment->toArray()))\n        ->toEqual([\n            'id',\n            'post_id',\n            'user_id',\n            'content',\n            'created_at',\n            'updated_at',\n        ]);\n});\n```\n\nAjoutons maintenant les relations. Un article possède plusieurs commentaires, un commentaire appartient à un article, un commentaire appartient à un utilisateur et un utilisateur possède plusieurs commentaires.\n\n::callout{icon=\"i-ph-info-duotone\" color=\"info\"}\nNous utilisons `belongs to` plutôt que `has one`, car un commentaire est un enfant d'un article et ne peut pas exister sans lui. Une relation `has one` décrit le modèle parent qui possède un enfant unique, comme un utilisateur qui possède un profil alors que le profil appartient à l'utilisateur.\n::\n\nVoici ces relations :\n\n```php [app\u002FModels\u002FPost.php]\nclass Post extends Model\n{\n    \u002F**\n     * Get all of the comments for the Post\n     *\n     * @return HasMany\u003CComment, covariant Post>\n     *\u002F\n    public function comments(): HasMany\n    {\n        return $this->hasMany(Comment::class);\n    }\n}\n```\n\n```php [app\u002FModels\u002FComment.php]\nclass Comment extends Model\n{\n    \u002F**\n     * Get the post that owns the comment.\n     *\n     * @return BelongsTo\u003CPost, covariant Comment>\n     *\u002F\n    public function post(): BelongsTo\n    {\n        return $this->belongsTo(Post::class);\n    }\n\n    \u002F**\n     * Get the user that owns the comment.\n     *\n     * @return BelongsTo\u003CUser, covariant Comment>\n     *\u002F\n    public function user(): BelongsTo\n    {\n        return $this->belongsTo(User::class);\n    }\n}\n```\n\n```php [app\u002FModels\u002FUser.php]\nclass User extends Authenticatable\n{\n    \u002F**\n     * Get comments that belong to the user.\n     *\n     * @return HasMany\u003CComment, covariant User>\n     *\u002F\n    public function comments(): HasMany\n    {\n        return $this->hasMany(Comment::class);\n    }\n}\n```\n\nCes relations simplifient les requêtes Eloquent. Pour récupérer tous les commentaires d'un article, nous pouvons écrire :\n\n```php [Exemple]\nPost::find(1)->comments;\n```\n\nElles facilitent également l'utilisation de méthodes de factory comme `has` et `for` pour créer des modèles liés.\n\nAjoutons des tests de relations pour vérifier que les modèles sont reliés comme prévu.\n\n::callout{icon=\"i-ph-info-duotone\" color=\"info\"}\nLorsque je travaille sur des modèles, j'écris souvent les tests après la première implémentation, car la conception peut évoluer rapidement. Écrire le modèle m'aide à clarifier ce que les tests doivent vérifier.\n::\n\n```php [tests\u002FUnit\u002FModels\u002FPostTest.php]\nuse App\\Models\\Comment;\n\ntest('relations', function () {\n    $post = Post::factory()\n        ->hasComments(1)\n        ->create();\n\n    expect($post->comments)->each->toBeInstanceOf(Comment::class);\n});\n```\n\n```php [tests\u002FUnit\u002FModels\u002FCommentTest.php]\nuse App\\Models\\Post;\nuse App\\Models\\User;\n\ntest('relations', function () {\n    $comment = Comment::factory()\n        ->forPost()\n        ->create();\n\n    expect($comment->post)->toBeInstanceOf(Post::class)\n        ->and($comment->user)->toBeInstanceOf(User::class);\n});\n```\n\n```php [tests\u002FUnit\u002FModels\u002FUserTest.php]\n\u003C?php\n\ndeclare(strict_types=1);\n\nuse App\\Models\\Comment;\nuse App\\Models\\User;\n\ntest('to array', function () {\n    $user = User::factory()->create()->fresh();\n\n    expect(array_keys($user->toArray()))\n        ->toEqual([\n            'id',\n            'name',\n            'username',\n            'email',\n            'email_verified_at',\n            'github_id',\n            'avatar',\n            'created_at',\n            'updated_at',\n        ]);\n});\n\ntest('relations', function () {\n    $user = User::factory()\n        ->hasComments(1)\n        ->create();\n\n    expect($user->comments)->each->toBeInstanceOf(Comment::class);\n});\n```\n\nNous n'avions pas encore ajouté de tests pour `User`, c'est donc une bonne occasion d'ajouter également son test de forme.\n\nLe fonctionnement reste cohérent et Laravel rend chaque étape simple.\n\n## Créer les contrôleurs\n\nMaintenant que les modèles sont prêts, nous pouvons créer les contrôleurs.\n\n`PostCommentController` possédera deux méthodes :\n\n- `index` : Liste tous les commentaires d'un article avec `GET \u002Fposts\u002F{post}\u002Fcomments`.\n- `store` : Crée un commentaire avec `POST \u002Fposts\u002F{post}\u002Fcomments`.\n\nComme dans l'article précédent, commençons par écrire un test pour la méthode `index` :\n\n```php [tests\u002FFeature\u002FHttp\u002FApi\u002FPost\u002FComment\u002FIndexTest.php]\n\u003C?php\n\ndeclare(strict_types=1);\n\nuse App\\Models\\Comment;\nuse App\\Models\\Post;\nuse Illuminate\\Testing\\Fluent\\AssertableJson;\n\nit('returns comments', function () {\n    $post = Post::factory()->create();\n    $comments = Comment::factory()\n        ->count(2)\n        ->for($post)\n        ->create();\n\n    $this->getJson(route('posts.comments', $post))\n        ->assertJson(\n            fn (AssertableJson $json) => $json\n                ->has(\n                    'data',\n                    2,\n                    fn (AssertableJson $json) => $json\n                        ->where('id', $comments->first()->id)\n                        ->where('content', $comments->first()->content)\n                        ->has(\n                            'author',\n                            fn (AssertableJson $json) => $json\n                                ->where('name', $comments->first()->user->name)\n                                ->where('username', $comments->first()->user->username)\n                                ->where('avatar', $comments->first()->user->avatar)\n                        )\n                )\n        );\n});\n```\n\nPour les tests HTTP, j'utilise le pattern `AAA` :\n\n- Arrange : préparer les données\n- Act : appeler la méthode\n- Assert : vérifier le résultat\n\nDans ce test, nous créons un article et deux commentaires associés. C'est l'étape `Arrange`. Nous appelons ensuite `GET \u002Fposts\u002F{post}\u002Fcomments`, l'étape `Act`. Enfin, nous vérifions que la réponse contient deux commentaires avec la structure attendue, l'étape `Assert`.\n\nLe test en échec nous demande d'ajouter une route dans `routes\u002Fapi.php` :\n\n```php [routes\u002Fapi.php]\n\u003C?php\n\nuse Illuminate\\Support\\Facades\\Route;\nuse App\\Http\\Controllers\\Api\\PostCommentController;\n\nRoute::get('\u002Fposts\u002F{post}\u002Fcomments', [PostCommentController::class, 'index'])\n    ->name('posts.comments');\n```\n\nNous devons ensuite demander à Laravel de lire ce fichier en mettant à jour `bootstrap\u002Fapp.php` :\n\n```php [bootstrap\u002Fapp.php]\n\u003C?php\n\ndeclare(strict_types=1);\n\nuse Illuminate\\Foundation\\Application;\nuse Illuminate\\Foundation\\Configuration\\Exceptions;\nuse Illuminate\\Foundation\\Configuration\\Middleware;\n\nreturn Application::configure(basePath: dirname(__DIR__))\n    ->withRouting(\n        web: __DIR__.'\u002F..\u002Froutes\u002Fweb.php',\n        api: __DIR__.'\u002F..\u002Froutes\u002Fapi.php', \u002F\u002F [!code ++]\n        commands: __DIR__.'\u002F..\u002Froutes\u002Fconsole.php',\n        health: '\u002Fup',\n    )\n```\n\nEnfin, créons le contrôleur avec une méthode `index` :\n\n```bash [terminal]\nphp artisan make:controller Api\u002FPostCommentController\n```\n\n```php [app\u002FHttp\u002FApi\u002FPostCommentController.php]\n\u003C?php\n\nnamespace App\\Http\\Controllers\\Api;\n\nuse App\\Http\\Controllers\\Controller;\nuse Illuminate\\Http\\Request;\n\nclass PostCommentController extends Controller\n{\n    public function index(Request $request)\n    {\n        \u002F\u002F\n    }\n}\n```\n\nLa route existe maintenant, mais le test indique que la réponse n'est pas un JSON valide, car le contrôleur ne retourne rien. 😄\n\nUtilisons cet échec comme prochaine étape d'implémentation :\n\n```php [app\u002FHttp\u002FApi\u002FPostCommentController.php]\n\u003C?php\n\ndeclare(strict_types=1);\n\nnamespace App\\Http\\Controllers\\Api;\n\nuse App\\Http\\Controllers\\Controller;\nuse App\\Http\\Resources\\CommentResource;\nuse App\\Models\\Comment;\nuse Illuminate\\Http\\Resources\\Json\\ResourceCollection;\n\nfinal class PostCommentController extends Controller\n{\n    public function index(): ResourceCollection\n    {\n        $comments = Comment::query()\n          ->with('user')\n          ->get();\n\n        return CommentResource::collection($comments);\n    }\n}\n```\n\nLa méthode `index` récupère les commentaires, charge la relation utilisateur à l'avance et retourne une collection de ressources `CommentResource`.\n\n::callout{icon=\"i-ph-info-duotone\" color=\"info\"}\nRécupérer tous les enregistrements n'est généralement pas une bonne pratique ; la pagination est plus sûre pour une grande collection. Dans cet exemple, nous nous attendons à un petit nombre de commentaires, le retour de la collection est donc acceptable. Nous pourrons ajouter la pagination si cette hypothèse change.\n::\n\nCréons maintenant la classe `CommentResource` :\n\n```bash [terminal]\nphp artisan make:resource CommentResource\n```\n\n```php [app\u002FHttp\u002FResources\u002FCommentResource.php]\n\u003C?php\n\ndeclare(strict_types=1);\n\nnamespace App\\Http\\Resources;\n\nuse App\\Models\\Comment;\nuse Illuminate\\Http\\Request;\nuse Illuminate\\Http\\Resources\\Json\\JsonResource;\n\n\u002F**\n * @mixin Comment\n *\u002F\nfinal class CommentResource extends JsonResource\n{\n    \u002F**\n     * Transform the resource into an array.\n     *\n     * @return array\u003Cstring, mixed>\n     *\u002F\n    public function toArray(Request $request): array\n    {\n        return [\n            'id' => $this->id,\n            'content' => $this->content,\n            'author' => UserResource::make($this->whenLoaded('user')),\n        ];\n    }\n}\n```\n\nEt une seconde ressource pour l'auteur :\n\n```bash [terminal]\nphp artisan make:resource UserResource\n```\n\n```php [app\u002FHttp\u002FResources\u002FUserResource.php]\n\u003C?php\n\ndeclare(strict_types=1);\n\nnamespace App\\Http\\Resources;\n\nuse App\\Models\\User;\nuse Illuminate\\Http\\Request;\nuse Illuminate\\Http\\Resources\\Json\\JsonResource;\n\n\u002F**\n * @mixin User\n *\u002F\nfinal class UserResource extends JsonResource\n{\n    \u002F**\n     * Transform the resource into an array.\n     *\n     * @return array\u003Cstring, mixed>\n     *\u002F\n    public function toArray(Request $request): array\n    {\n        return [\n            'name' => $this->name,\n            'username' => $this->username,\n            'avatar' => $this->avatar,\n        ];\n    }\n}\n```\n\nQue sont ces ressources ?\n\nUne ressource est une couche de transformation entre nos modèles Eloquent et les réponses JSON envoyées au client. Elle définit comment un modèle est transformé en JSON.\n\nIci, nous retournons l'`id`, le `content` et l'`author` d'un commentaire. La ressource imbriquée de l'auteur n'expose que le `name`, le `username` et l'`avatar` de l'utilisateur. Cela permet de modifier la forme de la réponse sans toucher au contrôleur et évite d'exposer accidentellement des champs comme l'e-mail de l'utilisateur.\n\nLe test devrait maintenant réussir. Mais ne nous précipitons pas : ajoutons un test pour vérifier que cette méthode ne retourne que les commentaires de l'article demandé :\n\n```php [tests\u002FFeature\u002FHttp\u002FApi\u002FPost\u002FComment\u002FIndexTest.php]\nit('returns comments for a post', function () {\n    Comment::factory()\n        ->count(2)\n        ->create();\n\n    $this->getJson(route('posts.comments', Post::factory()->create()))\n        ->assertJson(\n            fn (AssertableJson $json) => $json\n                ->has('data', 0)\n        );\n});\n```\n\nCe test crée deux commentaires pour un article, appelle la route avec un autre article et attend une réponse vide.\n\nLe test échoue, car le contrôleur ne filtre pas encore les commentaires par article.\n\nCorrigeons la méthode `index` :\n\n```php [app\u002FHttp\u002FApi\u002FPostCommentController.php]\nuse App\\Models\\Post;\n\nfinal class PostCommentController extends Controller\n{\n    public function index(Post $post): ResourceCollection\n    {\n        $comments = Comment::query()\n            ->whereBelongsTo($post)\n            ->with('user')\n            ->get();\n\n        return CommentResource::collection($comments);\n    }\n}\n```\n\nLe binding de modèle des routes de Laravel nous fournit directement l'instance `Post`. Comme la route contient `{post}` et que la méthode accepte un `Post`, Laravel recherche l'enregistrement correspondant et l'injecte. Le contrôleur reste ainsi concis.\n\nLes tests devraient maintenant réussir. 👌\n\nPassons à la méthode `store`.\n\nVous connaissez la méthode : commençons par écrire un test :\n\n```php [tests\u002FFeature\u002FHttp\u002FApi\u002FPost\u002FComment\u002FStoreTest.php]\n\u003C?php\n\nuse App\\Models\\Post;\n\nit('requires authentication', function () {\n    $post = Post::factory()->create();\n\n    $this->postJson(route('posts.comments.store', $post))\n        ->assertUnauthorized();\n});\n```\n\nCe test vérifie que l'authentification est requise. Ajoutez la route :\n\n```php [routes\u002Fapi.php]\nRoute::middleware('auth')->group(function () {\n    Route::post('\u002Fposts\u002F{post}\u002Fcomments', [PostCommentController::class, 'store'])\n        ->name('posts.comments.store');\n});\n```\n\nContinuons avec un autre test :\n\n```php [tests\u002FFeature\u002FHttp\u002FApi\u002FPost\u002FComment\u002FStoreTest.php]\nuse App\\Models\\User;\n\n\u002F\u002F ...\n\nit('stores a comment', function () {\n    $user = User::factory()->create();\n    $post = Post::factory()->create();\n\n    $this->actingAs($user)\n        ->postJson(route('posts.comments.store', $post), [\n            'content' => 'This is a comment',\n        ]);\n\n    $this->assertDatabaseHas('comments', [\n        'post_id' => $post->id,\n        'user_id' => $user->id,\n        'content' => 'This is a comment',\n    ]);\n});\n```\n\nCe test vérifie que le commentaire est enregistré avec le bon `post_id`, le bon `user_id` et le bon contenu. Le contrôleur définit les deux clés étrangères.\n\nNous pouvons maintenant implémenter la méthode `store` :\n\n```php [app\u002FHttp\u002FApi\u002FPostCommentController.php]\nfinal class PostCommentController extends Controller\n{\n    public function store(Request $request, Post $post)\n    {\n        Comment::create([\n            'post_id' => $post->id,\n            'user_id' => $request->user()->id,\n            'content' => $request->input('content')\n        ]);\n    }\n}\n```\n\n::callout{icon=\"i-ph-info-duotone\" color=\"info\"}\nNous écrivons uniquement le minimum nécessaire pour faire réussir les tests. Cela ne signifie pas que l'implémentation est terminée. Par exemple, la requête doit encore être validée, ce que nous ajouterons avec le prochain test.\n::\n\nAjoutons un test pour la validation de la requête :\n\n```php [tests\u002FFeature\u002FHttp\u002FApi\u002FPost\u002FComment\u002FStoreTest.php]\nit('requires a valid data', function (array $badData, array|string $errors) {\n    $post = Post::factory()->create();\n\n    $response = $this->actingAs(User::factory()->create())\n        ->postJson(route('posts.comments.store', $post), $badData);\n\n    $response->assertJsonValidationErrors($errors);\n})->with([\n    [['content' => ''], ['content' => 'The content field is required.']],\n    [['content' => 1], ['content' => 'The content field must be a string.']],\n    [['content' => 'a'], ['content' => 'The content field must be at least 6 characters.']],\n    [['content' => 'a'.str_repeat('a', 2001)], ['content' => 'The content field must not be greater than 2000 characters.']],\n]);\n```\n\nPest exécute ce test quatre fois avec des données différentes. Un dataset permet de couvrir plusieurs entrées invalides sans dupliquer le corps du test.\n\nCréons une classe `StoreCommentRequest` pour contenir ces règles :\n\n```bash [terminal]\nphp artisan make:request StoreCommentRequest\n```\n\n```php [app\u002FHttp\u002FRequests\u002FStoreCommentRequest.php]\n\u003C?php\n\nnamespace App\\Http\\Requests;\n\nuse Illuminate\\Foundation\\Http\\FormRequest;\n\nclass StoreCommentRequest extends FormRequest\n{\n    \u002F**\n     * Get the validation rules that apply to the request.\n     *\n     * @return array\u003Cstring, \\Illuminate\\Contracts\\Validation\\ValidationRule|array\u003Cmixed>|string>\n     *\u002F\n    public function rules(): array\n    {\n        return [\n            'content' => ['required', 'string', 'max:2000', 'min:6'],\n        ];\n    }\n}\n```\n\nMettez à jour `store` pour utiliser la nouvelle requête :\n\n```php [app\u002FHttp\u002FApi\u002FPostCommentController.php]\nuse App\\Http\\Requests\\StoreCommentRequest; \u002F\u002F [!code --]\nuse Illuminate\\Http\\Request; \u002F\u002F [!code --]\n\nfinal class PostCommentController extends Controller\n{\n    public function store(StoreCommentRequest $request, Post $post) \u002F\u002F [!code highlight]\n    {\n        \u002F\u002F ...\n    }\n}\n```\n\nLaravel valide maintenant la requête avant d'exécuter le contrôleur. ✨\n\nAjoutons enfin un test pour vérifier que les données retournées sont correctes :\n\n```php [tests\u002FFeature\u002FHttp\u002FApi\u002FPost\u002FComment\u002FStoreTest.php]\nit('returns the created comment', function () {\n    $user = User::factory()->create();\n    $post = Post::factory()->create();\n    $comment = Comment::factory()->make();\n\n    $response = $this->actingAs($user)\n        ->postJson(route('posts.comments.store', $post), [\n            'content' => $comment->content,\n        ]);\n\n    $comment = Comment::first();\n    $response\n        ->assertCreated()\n        ->assertJson(\n            fn (AssertableJson $json) => $json\n                ->has(\n                    'data',\n                    fn (AssertableJson $json) => $json\n                        ->where('id', $comment->id)\n                        ->where('content', $comment->content)\n                        ->has(\n                            'author',\n                            fn (AssertableJson $json) => $json\n                                ->where('name', $user->name)\n                                ->where('username', $user->username)\n                                ->where('avatar', $user->avatar)\n                        )\n                )\n        );\n});\n```\n\nCe test vérifie les données retournées et s'assure que le code HTTP est `201 Created` grâce à `assertCreated`.\n\nMettons à jour la méthode `store` pour retourner le commentaire créé :\n\n```php [app\u002FHttp\u002FApi\u002FPostCommentController.php]\nuse Illuminate\\Http\\Resources\\Json\\JsonResource;\n\nfinal class PostCommentController extends Controller\n{\n    public function store(StoreCommentRequest $request, Post $post): JsonResource\n    {\n        $comment = Comment::create([ \u002F\u002F [!code highlight]\n            'post_id' => $post->id,\n            'user_id' => $request->user()->id,\n            'content' => $request->input('content')\n        ]);\n\n        $comment->load('user'); \u002F\u002F [!code ++]\n\n        return CommentResource::make($comment); \u002F\u002F [!code ++]\n    }\n}\n```\n\nTous les tests devraient maintenant réussir.\n\nCes tests représentent les tests que vous pouvez écrire pour les autres contrôleurs.\n\n## Modifier et supprimer des commentaires\n\nNous pouvons maintenant implémenter la modification et la suppression des commentaires.\n\n::callout{icon=\"i-ph-info-duotone\" color=\"info\"}\nJe vais avancer plus vite ici, car le workflow est maintenant familier. Les tests complets sont inclus afin que vous puissiez suivre chaque exigence.\n::\n\nPour la modification, créons un nouveau fichier de test :\n\n```bash [terminal]\nmkdir -p tests\u002FHttp\u002FApi\u002FComment && touch tests\u002FHttp\u002FApi\u002FComment\u002FUpdateTest.php\n```\n\nAjoutons ensuite le test suivant :\n\n```php [tests\u002FHttp\u002FApi\u002FComment\u002FUpdateTest.php]\n\u003C?php\n\ndeclare(strict_types=1);\n\nuse App\\Models\\Comment;\nuse App\\Models\\User;\nuse Illuminate\\Testing\\Fluent\\AssertableJson;\n\nit('requires authentication', function () {\n    $comment = Comment::factory()->create();\n\n    $this->putJson(route('comments.update', $comment))\n        ->assertUnauthorized();\n});\n\nit('requires the user to be the author of the comment', function () {\n    $user = User::factory()->create();\n    $comment = Comment::factory()->create();\n\n    $this->actingAs($user)\n        ->putJson(route('comments.update', $comment), [\n            'content' => 'Updated content',\n        ])\n        ->assertForbidden();\n});\n\nit('updates a comment', function () {\n    $user = User::factory()->create();\n    $comment = Comment::factory()\n        ->for($user)\n        ->create();\n\n    $this->actingAs($user)\n        ->putJson(route('comments.update', $comment), [\n            'content' => 'Updated content',\n        ]);\n\n    $this->assertDatabaseHas('comments', [\n        'id' => $comment->id,\n        'content' => 'Updated content',\n    ]);\n});\n\nit('requires a valid data', function (array $badData, array|string $errors) {\n    $user = User::factory()->create();\n    $comment = Comment::factory()->for($user)->create();\n\n    $this->actingAs($user)\n        ->putJson(route('comments.update', $comment), $badData)\n        ->assertJsonValidationErrors($errors);\n})->with([\n    [['content' => ''], ['content' => 'The content field is required.']],\n    [['content' => 1], ['content' => 'The content field must be a string.']],\n    [['content' => 'a'], ['content' => 'The content field must be at least 6 characters.']],\n    [['content' => 'a' . str_repeat('a', 2001)], ['content' => 'The content field must not be greater than 2000 characters.']],\n]);\n\nit('returns the comment', function () {\n    $user = User::factory()->create();\n    $comment = Comment::factory()->for($user)->create();\n\n    $this->actingAs($user)\n        ->putJson(route('comments.update', $comment), [\n            'content' => 'Updated content',\n        ])\n        ->assertOk()\n        ->assertJson(\n            fn(AssertableJson $json) => $json\n                ->has(\n                    'data',\n                    fn(AssertableJson $json) => $json\n                        ->where('id', $comment->id)\n                        ->where('content', 'Updated content')\n                        ->has(\n                            'author',\n                            fn(AssertableJson $json) => $json\n                                ->where('name', $user->name)\n                                ->where('username', $user->username)\n                                ->where('avatar', $user->avatar)\n                        )\n                )\n        );\n});\n```\n\nAjoutons ensuite la route :\n\n```php [routes\u002Fapi.php]\n\u003C?php\n\nuse App\\Http\\Controllers\\Api\\CommentController; \u002F\u002F [!code ++]\n\nRoute::middleware('auth')->group(function () {\n    Route::put('\u002Fcomments\u002F{comment}', [CommentController::class, 'update']) \u002F\u002F [!code ++]\n        ->name('comments.update'); \u002F\u002F [!code ++]\n});\n```\n\nCréons le contrôleur :\n\n```bash [terminal]\nphp artisan make:controller Api\u002FCommentController\n```\n\nImplémentons la méthode `update` :\n\n```php [app\u002FHttp\u002FApi\u002FCommentController.php]\n\u003C?php\n\ndeclare(strict_types=1);\n\nnamespace App\\Http\\Controllers\\Api;\n\nuse App\\Http\\Controllers\\Controller;\nuse App\\Http\\Requests\\UpdateCommentRequest;\nuse App\\Http\\Resources\\CommentResource;\nuse App\\Models\\Comment;\nuse Illuminate\\Http\\Resources\\Json\\JsonResource;\n\nfinal class CommentController extends Controller\n{\n    public function update(UpdateCommentRequest $request, Comment $comment): JsonResource\n    {\n        $comment->update($request->validated());\n        $comment->load('user');\n\n        return CommentResource::make($comment);\n    }\n}\n```\n\nCette méthode a besoin d'une form request dédiée :\n\n```bash [terminal]\nphp artisan make:request UpdateCommentRequest\n```\n\nImplémentons cette requête :\n\n```php [app\u002FHttp\u002FRequests\u002FUpdateCommentRequest.php]\n\u003C?php\n\ndeclare(strict_types=1);\n\nnamespace App\\Http\\Requests;\n\nuse App\\Models\\Comment;\nuse Illuminate\\Foundation\\Http\\FormRequest;\n\n\u002F**\n * @property Comment $comment\n *\u002F\nfinal class UpdateCommentRequest extends FormRequest\n{\n    \u002F**\n     * Determine if the user is authorized to make this request.\n     *\u002F\n    public function authorize(): bool\n    {\n        return $this->user()->can('update', $this->comment);\n    }\n\n    \u002F**\n     * Get the validation rules that apply to the request.\n     *\n     * @return array\u003Cstring, \\Illuminate\\Contracts\\Validation\\ValidationRule|array\u003Cmixed>|string>\n     *\u002F\n    public function rules(): array\n    {\n        return [\n            'content' => ['required', 'string', 'max:2000', 'min:6'],\n        ];\n    }\n}\n```\n\nLa méthode `authorize` de la requête vérifie si l'utilisateur courant peut modifier le commentaire. Elle délègue cette décision à une policy, que nous devons créer.\n\n```bash [terminal]\nphp artisan make:policy CommentPolicy\n```\n\nImplémentons ensuite la policy :\n\n```php [app\u002FPolicies\u002FCommentPolicy.php]\n\u003C?php\n\nnamespace App\\Policies;\n\nuse App\\Models\\Comment;\nuse App\\Models\\User;\n\nclass CommentPolicy\n{\n    \u002F**\n     * Determine whether the user can update the model.\n     *\u002F\n    public function update(User $user, Comment $comment): bool\n    {\n        return $user->id === $comment->user_id;\n    }\n}\n```\n\nLe flux de modification est maintenant terminé.\n\nTerminons l'article en ajoutant la suppression d'un commentaire :\n\n```php [tests\u002FHttp\u002FApi\u002FComment\u002FDestroyTest.php]\n\u003C?php\n\ndeclare(strict_types=1);\n\nuse App\\Models\\Comment;\nuse App\\Models\\User;\n\nit('requires authentification', function () {\n    $comment = Comment::factory()->create();\n\n    $this->deleteJson(route('comments.destroy', $comment))\n        ->assertUnauthorized();\n});\n\nit('requires the user to be the author of the comment', function () {\n    $user = User::factory()->create();\n    $comment = Comment::factory()->create();\n\n    $this->actingAs($user)\n        ->deleteJson(route('comments.destroy', $comment))\n        ->assertForbidden();\n});\n\nit('deletes a comment', function () {\n    $user = User::factory()->create();\n    $comment = Comment::factory()->for($user)->create();\n\n    $this->actingAs($user)\n        ->deleteJson(route('comments.destroy', $comment));\n\n    $this->assertDatabaseMissing('comments', [\n        'id' => $comment->id,\n    ]);\n});\n```\n\n```php [routes\u002Fapi.php]\n\u003C?php\n\n\u002F\u002F ...\n\nRoute::middleware('auth')->group(function () {\n    \u002F\u002F ...\n\n    Route::delete('\u002Fcomments\u002F{comment}', [CommentController::class, 'destroy'])\n        ->name('comments.destroy');\n});\n\n```\n\n```php [app\u002FHttp\u002FApi\u002FCommentController.php]\nuse Illuminate\\Http\\Response;\nuse Illuminate\\Support\\Facades\\Gate;\n\nfinal class CommentController extends Controller\n{\n    \u002F\u002F ...\n\n    public function destroy(Comment $comment): Response\n    {\n        Gate::authorize('delete', $comment);\n\n        $comment->delete();\n\n        return response()->noContent();\n    }\n}\n```\n\nLa façade `Gate` autorise la suppression. Laravel résout `CommentPolicy` à partir du modèle transmis à `authorize`.\n\n```php [app\u002FPolicies\u002FCommentPolicy.php]\nfinal class CommentPolicy\n{\n    \u002F\u002F ...\n\n    \u002F**\n     * Determine whether the user can delete the model.\n     *\u002F\n    public function delete(User $user, Comment $comment): bool\n    {\n        return $user->id === $comment->user_id;\n    }\n}\n```\n\nLe système de commentaires est prêt et les tests nous donnent confiance dans ses principaux comportements sans nécessiter de tout vérifier manuellement.\n\n## Et maintenant ?\n\nL'API de commentaires est maintenant en place. Elle permet de lister, créer, modifier et supprimer des commentaires, tandis que les tests décrivent les comportements et les permissions qui protègent ces opérations.\n\nLe développement piloté par les tests a permis de rester concentré : chaque échec indiquait le comportement à ajouter, et les tests terminés nous protègent désormais contre les régressions.\n\nEnsuite, nous connecterons le front-end statique au back-end. Nous générerons les métadonnées des articles pendant le build VitePress et utiliserons Laravel pour synchroniser automatiquement la table `posts`.\n",{"title":5,"description":4587},"empower-and-dynamize-our-vitepress-blog-with-a-laravel-api",{"loc":4591},"fr\u002Fseries\u002Fempower-and-dynamize-our-vitepress-blog-with-a-laravel-api\u002Fbuilding-a-simple-comment-system-for-user-engagement","ivMpVbTdSZYJN0i5ouHWr4ZxI2-4xSwd9EPtDkTDKpw",{"overview":4599,"chapters":4773},{"id":4600,"title":4601,"body":4602,"contentId":4757,"date":4758,"description":4759,"extension":4588,"github":4589,"meetTheInstructor":4760,"meta":4761,"navigation":453,"part":4589,"path":4762,"rawbody":4763,"robots":4589,"schemaOrg":4589,"seo":4764,"seriesSlug":4594,"sitemap":4765,"stem":4766,"subtitle":4767,"topics":4768,"__hash__":4772},"series\u002Ffr\u002Fseries\u002Fempower-and-dynamize-our-vitepress-blog-with-a-laravel-api.md","Améliorer votre blog VitePress avec une API Laravel",{"type":7,"value":4603,"toc":4754},[4604,4607,4610,4613,4617,4626,4629,4638,4641,4644,4726,4729,4732,4735,4744,4748],[10,4605,4606],{},"Bonjour ! 👋",[10,4608,4609],{},"Après avoir créé notre blog VitePress, nous sommes prêts à le rendre plus dynamique grâce à une API Laravel.",[10,4611,4612],{},"Dans la série précédente, nous avons découvert VitePress, de la création du projet jusqu'à son déploiement sur Cloudflare Pages. Nous avons construit un blog fonctionnel et automatisé, avec des métadonnées SEO, des images Open Graph et une page dédiée aux projets GitHub. Le blog gérait tout au moment de sa génération : il ne restait plus qu'à écrire et publier du contenu.",[4614,4615],"callout-read-more",{"id":4616},"43c95b33-041c-4108-ab98-0d21ef60ed7f",[10,4618,4619,4620,4625],{},"Cette série s'intéresse au développement back-end. Nous allons créer une API ",[226,4621,4624],{"href":4622,"rel":4623},"https:\u002F\u002Flaravel.com",[230],"Laravel"," pour ajouter quelques fonctionnalités interactives à notre blog.",[10,4627,4628],{},"Jusqu'à présent, notre blog était principalement statique. Le contenu était généré lors du build, avec seulement quelques données chargées dynamiquement, puis les fichiers HTML résultants étaient distribués par un CDN. En ajoutant une API Laravel, nous permettrons aux lecteurs d'interagir avec le blog grâce à des fonctionnalités comme les réactions et les commentaires.",[10,4630,4631,4632,4637],{},"Même si la série se concentre sur le back-end, nous intégrerons également l'API à notre blog VitePress. Nous utiliserons Vue.js et ",[226,4633,4636],{"href":4634,"rel":4635},"https:\u002F\u002Fpinia-colada.esm.dev\u002F",[230],"Pinia Colada"," pour récupérer les données. VitePress est une application Vue.js, nous pouvons donc l'étendre avec les composants dont nous avons besoin.",[10,4639,4640],{},"Les exemples sont conçus pour rester faciles à suivre. La complexité inutile et la sur-ingénierie n'ont pas leur place ici. Nous nous concentrerons sur la simplicité, la clarté et l'efficacité.",[10,4642,4643],{},"Tout au long de la série, nous construirons une API Laravel et l'intégrerons à notre blog VitePress. Nous aborderons les sujets suivants :",[17,4645,4646,4653,4681,4692,4698,4708,4714,4720],{},[20,4647,4648,4652],{},[4649,4650,4651],"strong",{},"Configurer le projet Laravel"," : Créer un nouveau projet Laravel et se familiariser avec sa structure.",[20,4654,4655,4658,4659,4664,4665,4664,4670,1261,4675,4680],{},[4649,4656,4657],{},"Améliorer le workflow de développement"," : Configurer ",[226,4660,4663],{"href":4661,"rel":4662},"https:\u002F\u002Flaravel.com\u002Fdocs\u002F11.x\u002Fpint",[230],"Pint",", ",[226,4666,4669],{"href":4667,"rel":4668},"https:\u002F\u002Fgithub.com\u002Frectorphp\u002Frector",[230],"Rector",[226,4671,4674],{"href":4672,"rel":4673},"https:\u002F\u002Fgithub.com\u002Flarastan\u002Flarastan",[230],"Larastan",[226,4676,4679],{"href":4677,"rel":4678},"https:\u002F\u002Fpestphp.com\u002F",[230],"Pest"," pour le formatage, la refactorisation, l'analyse statique et les tests.",[20,4682,4683,4686,4687,327],{},[4649,4684,4685],{},"Ajouter l'authentification sociale"," : Permettre aux utilisateurs de se connecter avec GitHub grâce à ",[226,4688,4691],{"href":4689,"rel":4690},"https:\u002F\u002Flaravel.com\u002Fdocs\u002F11.x\u002Fsocialite",[230],"Laravel Socialite",[20,4693,4694,4697],{},[4649,4695,4696],{},"Connecter les applications"," : Configurer Sanctum, CORS, la protection CSRF et les premières requêtes entre le front-end VitePress et l'API Laravel.",[20,4699,4700,4703,4704,4707],{},[4649,4701,4702],{},"Gérer l'état d'authentification"," : Utiliser ",[226,4705,4636],{"href":4634,"rel":4706},[230]," pour récupérer l'utilisateur courant et le déconnecter avec une mise à jour optimiste.",[20,4709,4710,4713],{},[4649,4711,4712],{},"Construire l'API de commentaires"," : Créer les modèles, les relations, les endpoints, la validation, l'autorisation et les tests des commentaires.",[20,4715,4716,4719],{},[4649,4717,4718],{},"Garder le back-end synchronisé"," : Générer les métadonnées des articles depuis VitePress et les synchroniser avec la base de données Laravel.",[20,4721,4722,4725],{},[4649,4723,4724],{},"Construire l'interface de commentaires"," : Récupérer, créer, modifier et supprimer des commentaires depuis le front-end VitePress.",[10,4727,4728],{},"À la fin de la série, vous aurez un blog soutenu par une API Laravel. Les lecteurs pourront se connecter avec GitHub et laisser des commentaires, tandis que l'architecture sera prête à accueillir d'autres fonctionnalités interactives.",[10,4730,4731],{},"Les tests feront partie du processus de développement et seront ajoutés à chaque étape. Il n'est donc pas nécessaire de leur consacrer un article séparé.",[10,4733,4734],{},"Si vous avez des questions, des retours ou des suggestions, n'hésitez pas à les partager dans les commentaires. Vos remarques contribuent à améliorer la série.",[36,4736,4737],{"color":38,"icon":39},[10,4738,4739,4740,327],{},"Cette série suppose que vous connaissez déjà TypeScript, Vue.js et Laravel. Si ce n'est pas le cas, commencez par consulter la ",[226,4741,4743],{"href":4742},"\u002Ffr\u002Fseries\u002Fcreate-a-blog-with-vitepress-and-vue-js-from-scratch","Créer un Blog Complet avec VitePress et Vue.js de Zéro",[44,4745,4747],{"id":4746},"chapitres","Chapitres",[4749,4750],"series-chapters-list",{"className":4751},[4752,4753],"mx-auto","max-w-5xl",{"title":257,"searchDepth":288,"depth":288,"links":4755},[4756],{"id":4746,"depth":288,"text":4747},"c95f7904-8ade-4f11-84a8-99688d26c036","2024-11-19","Transformez votre blog VitePress en une plateforme dynamique avec une API Laravel et ajoutez-lui des fonctionnalités interactives.","J'ai créé cette série parce que j'aime \u003Cstrong>VitePress\u003C\u002Fstrong> et \u003Cstrong>Laravel\u003C\u002Fstrong>. Je suis convaincu que leur association offre une solution simple et \u003Cstrong>puissante\u003C\u002Fstrong> pour créer un blog. Je souhaite aider les développeurs à enrichir leurs blogs VitePress avec une API Laravel afin de créer des fonctionnalités avancées.",{},"\u002Ffr\u002Fseries\u002Fempower-and-dynamize-our-vitepress-blog-with-a-laravel-api","---\ncontentId: c95f7904-8ade-4f11-84a8-99688d26c036\ntitle: Améliorer votre blog VitePress avec une API Laravel\nsubtitle: Transformez votre blog VitePress en une plateforme dynamique avec une API\ndescription: Transformez votre blog VitePress en une plateforme dynamique avec une API Laravel et ajoutez-lui des fonctionnalités interactives.\ndate: 2024-11-19\ntopics:\n  - laravel\n  - vitepress\n  - api\nmeetTheInstructor: J'ai créé cette série parce que j'aime \u003Cstrong>VitePress\u003C\u002Fstrong> et \u003Cstrong>Laravel\u003C\u002Fstrong>. Je suis convaincu que leur association offre une solution simple et \u003Cstrong>puissante\u003C\u002Fstrong> pour créer un blog. Je souhaite aider les développeurs à enrichir leurs blogs VitePress avec une API Laravel afin de créer des fonctionnalités avancées.\nseriesSlug: empower-and-dynamize-our-vitepress-blog-with-a-laravel-api\n---\n\nBonjour ! 👋\n\nAprès avoir créé notre blog VitePress, nous sommes prêts à le rendre plus dynamique grâce à une API Laravel.\n\nDans la série précédente, nous avons découvert VitePress, de la création du projet jusqu'à son déploiement sur Cloudflare Pages. Nous avons construit un blog fonctionnel et automatisé, avec des métadonnées SEO, des images Open Graph et une page dédiée aux projets GitHub. Le blog gérait tout au moment de sa génération : il ne restait plus qu'à écrire et publier du contenu.\n\n\u003CCalloutReadMore id=\"43c95b33-041c-4108-ab98-0d21ef60ed7f\" \u002F>\n\nCette série s'intéresse au développement back-end. Nous allons créer une API [Laravel](https:\u002F\u002Flaravel.com) pour ajouter quelques fonctionnalités interactives à notre blog.\n\nJusqu'à présent, notre blog était principalement statique. Le contenu était généré lors du build, avec seulement quelques données chargées dynamiquement, puis les fichiers HTML résultants étaient distribués par un CDN. En ajoutant une API Laravel, nous permettrons aux lecteurs d'interagir avec le blog grâce à des fonctionnalités comme les réactions et les commentaires.\n\nMême si la série se concentre sur le back-end, nous intégrerons également l'API à notre blog VitePress. Nous utiliserons Vue.js et [Pinia Colada](https:\u002F\u002Fpinia-colada.esm.dev\u002F) pour récupérer les données. VitePress est une application Vue.js, nous pouvons donc l'étendre avec les composants dont nous avons besoin.\n\nLes exemples sont conçus pour rester faciles à suivre. La complexité inutile et la sur-ingénierie n'ont pas leur place ici. Nous nous concentrerons sur la simplicité, la clarté et l'efficacité.\n\nTout au long de la série, nous construirons une API Laravel et l'intégrerons à notre blog VitePress. Nous aborderons les sujets suivants :\n\n- **Configurer le projet Laravel** : Créer un nouveau projet Laravel et se familiariser avec sa structure.\n- **Améliorer le workflow de développement** : Configurer [Pint](https:\u002F\u002Flaravel.com\u002Fdocs\u002F11.x\u002Fpint), [Rector](https:\u002F\u002Fgithub.com\u002Frectorphp\u002Frector), [Larastan](https:\u002F\u002Fgithub.com\u002Flarastan\u002Flarastan) et [Pest](https:\u002F\u002Fpestphp.com\u002F) pour le formatage, la refactorisation, l'analyse statique et les tests.\n- **Ajouter l'authentification sociale** : Permettre aux utilisateurs de se connecter avec GitHub grâce à [Laravel Socialite](https:\u002F\u002Flaravel.com\u002Fdocs\u002F11.x\u002Fsocialite).\n- **Connecter les applications** : Configurer Sanctum, CORS, la protection CSRF et les premières requêtes entre le front-end VitePress et l'API Laravel.\n- **Gérer l'état d'authentification** : Utiliser [Pinia Colada](https:\u002F\u002Fpinia-colada.esm.dev\u002F) pour récupérer l'utilisateur courant et le déconnecter avec une mise à jour optimiste.\n- **Construire l'API de commentaires** : Créer les modèles, les relations, les endpoints, la validation, l'autorisation et les tests des commentaires.\n- **Garder le back-end synchronisé** : Générer les métadonnées des articles depuis VitePress et les synchroniser avec la base de données Laravel.\n- **Construire l'interface de commentaires** : Récupérer, créer, modifier et supprimer des commentaires depuis le front-end VitePress.\n\nÀ la fin de la série, vous aurez un blog soutenu par une API Laravel. Les lecteurs pourront se connecter avec GitHub et laisser des commentaires, tandis que l'architecture sera prête à accueillir d'autres fonctionnalités interactives.\n\nLes tests feront partie du processus de développement et seront ajoutés à chaque étape. Il n'est donc pas nécessaire de leur consacrer un article séparé.\n\nSi vous avez des questions, des retours ou des suggestions, n'hésitez pas à les partager dans les commentaires. Vos remarques contribuent à améliorer la série.\n\n::callout{icon=\"i-ph-info-duotone\" color=\"info\"}\nCette série suppose que vous connaissez déjà TypeScript, Vue.js et Laravel. Si ce n'est pas le cas, commencez par consulter la [Créer un Blog Complet avec VitePress et Vue.js de Zéro](\u002Ffr\u002Fseries\u002Fcreate-a-blog-with-vitepress-and-vue-js-from-scratch).\n::\n\n## Chapitres\n\n::series-chapters-list\n---\nclass: mx-auto max-w-5xl\n---\n::\n",{"title":4601,"description":4759},{"loc":4762},"fr\u002Fseries\u002Fempower-and-dynamize-our-vitepress-blog-with-a-laravel-api","Transformez votre blog VitePress en une plateforme dynamique avec une API",[4769,4770,4771],"laravel","vitepress","api","AjkLB8gOXMZAgudegF8LmVWjly_nRao_7y_u2LUCUrQ",[4774,4779,4784,4789,4790,4795,4800,4805],{"contentId":4775,"title":4776,"description":4777,"path":4778,"part":264,"github":4589,"topics":4589},"61204f3d-47bc-4832-a217-8c00b11ab6e1","Configurer la structure et les bases d'un projet Laravel","Découvrez comment configurer un projet Laravel et comprendre sa structure pour commencer le développement sur des bases solides.","\u002Ffr\u002Fseries\u002Fempower-and-dynamize-our-vitepress-blog-with-a-laravel-api\u002Fsetting-up-your-laravel-project-structure-and-essentials",{"contentId":4780,"title":4781,"description":4782,"path":4783,"part":288,"github":4589,"topics":4589},"9446fd4c-5ffd-4b4b-8cc2-8075ef1c7a00","Pint, Rector, Larastan et Pest : les essentiels pour réussir","Découvrez quatre outils indispensables pour maintenir la qualité et la cohérence du code dans les projets Laravel : Pint, Rector, Larastan et Pest.","\u002Ffr\u002Fseries\u002Fempower-and-dynamize-our-vitepress-blog-with-a-laravel-api\u002Fpint-larastan-rector-and-pest-essential-for-success",{"contentId":4785,"title":4786,"description":4787,"path":4788,"part":316,"github":4589,"topics":4589},"d9a64441-89b3-4f82-a356-10bde7db7669","Authentification sociale simplifiée avec Laravel Socialite","Ajoutez l'authentification GitHub à Laravel avec Socialite, les callbacks OAuth, la synchronisation des utilisateurs et des tests fiables.","\u002Ffr\u002Fseries\u002Fempower-and-dynamize-our-vitepress-blog-with-a-laravel-api\u002Feffortless-social-authentication-with-laravel-socialite",{"contentId":4585,"title":5,"description":4587,"path":4591,"part":347,"github":4589,"topics":4589},{"contentId":4791,"title":4792,"description":4793,"path":4794,"part":373,"github":4589,"topics":4589},"1cf0ee5e-a0df-4f7d-b281-a083099223e9","Automatiser facilement la synchronisation de votre back-end","Générez les métadonnées avec VitePress, synchronisez les articles avec Laravel et gardez automatiquement la base de données à jour.","\u002Ffr\u002Fseries\u002Fempower-and-dynamize-our-vitepress-blog-with-a-laravel-api\u002Fautomating-your-backend-to-stay-in-sync-effortlessly",{"contentId":4796,"title":4797,"description":4798,"path":4799,"part":457,"github":4589,"topics":4589},"dfedb4f0-badf-4a05-8b62-977c61fd6d11","Connecter le front-end, VitePress et le back-end, Laravel","Connectez un front-end VitePress à une API Laravel avec Sanctum, CORS, la protection CSRF et un client API réutilisable.","\u002Ffr\u002Fseries\u002Fempower-and-dynamize-our-vitepress-blog-with-a-laravel-api\u002Fbridging-the-gap-connecting-your-frontend-and-backend",{"contentId":4801,"title":4802,"description":4803,"path":4804,"part":463,"github":4589,"topics":4589},"e03c822f-0431-4ece-9293-765cacc2d44e","Authentifier les utilisateurs du front-end au back-end","Reliez l'authentification front-end à Laravel avec une requête utilisateur, une déconnexion GitHub, le cache Pinia Colada et des mises à jour optimistes.","\u002Ffr\u002Fseries\u002Fempower-and-dynamize-our-vitepress-blog-with-a-laravel-api\u002Fstreamlining-user-authentication-from-frontend-to-backend",{"contentId":4806,"title":4807,"description":4808,"path":4809,"part":469,"github":4589,"topics":4589},"6ba25b9d-f306-42c5-b788-348fc90c6740","Simplifier les commentaires de VitePress avec Pinia Colada","Construisez l'interface de commentaires VitePress avec Pinia Colada, des composants Vue réutilisables, des mutations optimistes et des permissions.","\u002Ffr\u002Fseries\u002Fempower-and-dynamize-our-vitepress-blog-with-a-laravel-api\u002Fsimplifying-comment-querying-and-editing-with-pinia-colada",1795016704149]