5ea1026151
* feat(recipes): ajoute un adaptateur RecipeSourceAdapter pour Marmiton Étend jsonLdRecipeAdapter (json-ld-recipe.ts) plutôt que de dupliquer sa logique : marmitonAdapter délègue fetchDetail/parse directement à l'adaptateur générique JSON-LD (une page recette marmiton.org expose un Recipe schema.org standard), et n'ajoute que ce que l'adaptateur générique ne peut pas offrir — un list() qui lit l'ItemList schema.org embarqué sur la page de résultats de recherche de marmiton.org (pagination via &page=N, fin de résultats détectée via la réponse 404 renvoyée au-delà de la dernière page). extractJsonLdBlocks est exporté depuis json-ld-recipe.ts pour être réutilisé par marmiton.ts sans dupliquer le regex d'extraction des blocs <script type="application/ld+json">. Enregistre marmitonAdapter dans registerAllRecipeSources (sources/index.ts) — contrairement à jsonLdRecipeAdapter lui-même, c'est un adaptateur concret par site, donc une Source household-toggleable légitime. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com> * feat(recipes): ajoute un adaptateur RecipeSourceAdapter pour 750g Suit le même schéma que marmitonAdapter (construit sur jsonLdRecipeAdapter), avec deux différences propres à 750g.com : - list() n'a pas d'ItemList JSON-LD à lire sur ses résultats de recherche (la recherche du site est un widget client-side) — appelle donc directement le endpoint GET que ce widget interroge lui-même en interne (un « moteur de réponse IA » qui renvoie un lot de recettes pour une requête en texte libre), et scrape les cartes de résultat par regex en associant à chaque lien de recette sa dernière image précédente plutôt qu'un zip naïf par index (des images décoratives sans carte associée existent réellement dans ce fragment). Vérifié en direct : demander une « page 2 » revient toujours vide, donc nextCursor vaut toujours null, comme theMealDbAdapter. - parse() ne délègue pas aussi directement à jsonLdRecipeAdapter.parse que marmitonAdapter — le générateur JSON-LD de 750g.com a deux bugs réels : des caractères de contrôle bruts non échappés dans certaines chaînes JSON (~1 recette sur 3 dans un échantillon vérifié en direct, sinon JSON.parse échoue et jsonLdRecipeAdapter rapporte à tort « aucun Recipe trouvé »), et un texte parfois doublement encodé en entités HTML (ex. un vrai « é » devient &eacute; au lieu de é). Les deux sont corrigés en pré/post-traitement autour de la même délégation, pas une réimplémentation. Enregistre sevenFiftyGAdapter dans registerAllRecipeSources (sources/index.ts), au même titre que marmitonAdapter. Complète aussi test/sources/sources-index.test.ts, qui ne couvrait encore que TheMealDB malgré l'ajout de Marmiton dans une PR précédente. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com> * feat(recipes): ajoute un adaptateur RecipeSourceAdapter pour Manger Bouger Suit le même schéma que marmitonAdapter/sevenFiftyGAdapter (construit sur jsonLdRecipeAdapter), avec des différences propres à mangerbouger.fr (« La Fabrique à Menus », Santé publique France) : - list() n'utilise pas de JSON-LD du tout — la page de résultats (une app Next.js) n'embarque aucun ItemList. Elle est cependant rendue côté serveur et expose le même state Redux que le client hydrate, via un <script id="__NEXT_DATA__">, qui contient déjà tout ce dont list() a besoin (slug/nom/image, pagination). Vérifié en direct : ?query=<texte libre> filtre bien côté serveur, et hasMorePages donne un signal de fin de pagination plus propre que le 404 de Marmiton ou l'absence de vraie pagination de 750g. - parse() délègue à jsonLdRecipeAdapter mais corrige deux lacunes réelles et systématiques de son propre JSON-LD (vérifiées sur 9 recettes, 72 étapes) : recipeInstructions[].text est un document Slate.js sérialisé en JSON (pas du texte) plutôt qu'être aplati ; recipeYield est absent partout alors que le nombre de portions existe bien côté site (__NEXT_DATA__) — les deux sont corrigés par un patch structuré (parse → mutation → réécriture) avant délégation, pas une réimplémentation. Enregistre mangerBougerAdapter dans registerAllRecipeSources (sources/index.ts) et complète sources-index.test.ts. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com> --------- Co-authored-by: Claude Sonnet 5 <noreply@anthropic.com>
226 lines
7.7 KiB
TypeScript
226 lines
7.7 KiB
TypeScript
import { expect } from "chai";
|
|
import {
|
|
RecipeSourceFetchError,
|
|
RecipeSourceParseError,
|
|
} from "../../src/lib/recipe-sources/recipe-source-errors.js";
|
|
import { marmitonAdapter } from "../../src/sources/marmiton.js";
|
|
|
|
/** Stubs `globalThis.fetch` to return `html` as the response body — same pattern as `json-ld-recipe.test.ts`'s `stubFetchHtml`. */
|
|
function stubFetchHtml(html: string, status = 200) {
|
|
globalThis.fetch = (async () => new Response(html, { status })) as typeof fetch;
|
|
}
|
|
|
|
/**
|
|
* Wraps a schema.org `ItemList` payload (already an object, not yet
|
|
* stringified) in a minimal HTML page carrying it as one
|
|
* `<script type="application/ld+json">` block — the shape marmiton.org's
|
|
* search-results page embeds `list()` reads.
|
|
*/
|
|
function htmlWithItemListJsonLd(itemListElement: unknown[]): string {
|
|
const payload = {
|
|
"@context": "https://schema.org",
|
|
"@graph": [
|
|
{ "@type": "WebSite", name: "Marmiton" },
|
|
{
|
|
"@type": "ItemList",
|
|
"@id": "https://www.marmiton.org/recettes/recherche.aspx?aqt=poulet#itemlist",
|
|
numberOfItems: itemListElement.length,
|
|
itemListElement,
|
|
},
|
|
],
|
|
};
|
|
return `<!doctype html><html><head><script type="application/ld+json">${JSON.stringify(
|
|
payload,
|
|
)}</script></head><body></body></html>`;
|
|
}
|
|
|
|
const RECIPE_URL = "https://www.marmiton.org/recettes/recette_tarte-aux-pommes_11457.aspx";
|
|
|
|
const baseListItem = {
|
|
"@type": "ListItem",
|
|
position: 1,
|
|
url: RECIPE_URL,
|
|
name: "Tarte aux pommes",
|
|
image: "https://assets.afcdn.com/recipe/tarte.jpg",
|
|
};
|
|
|
|
const baseRecipeJsonLd = {
|
|
"@context": "https://schema.org",
|
|
"@type": "Recipe",
|
|
name: "Tarte aux pommes",
|
|
description: "Une tarte aux pommes classique.",
|
|
image: "https://assets.afcdn.com/recipe/tarte.jpg",
|
|
recipeYield: "6 personnes",
|
|
recipeIngredient: ["3 pommes", "1 pâte brisée"],
|
|
recipeInstructions: [
|
|
{ "@type": "HowToStep", text: "Épluchez les pommes." },
|
|
{ "@type": "HowToStep", text: "Enfournez 30 minutes." },
|
|
],
|
|
};
|
|
|
|
function htmlWithRecipeJsonLd(): string {
|
|
return `<!doctype html><html><head><script type="application/ld+json">${JSON.stringify(
|
|
baseRecipeJsonLd,
|
|
)}</script></head><body></body></html>`;
|
|
}
|
|
|
|
describe("marmitonAdapter", () => {
|
|
let originalFetch: typeof fetch;
|
|
|
|
beforeEach(() => {
|
|
originalFetch = globalThis.fetch;
|
|
});
|
|
|
|
afterEach(() => {
|
|
globalThis.fetch = originalFetch;
|
|
});
|
|
|
|
it("declares itself as an unofficial, French-locale source with an icon", () => {
|
|
expect(marmitonAdapter.key).to.equal("marmiton");
|
|
expect(marmitonAdapter.name).to.equal("Marmiton");
|
|
expect(marmitonAdapter.official).to.equal(false);
|
|
expect(marmitonAdapter.iconUrl).to.be.a("string");
|
|
expect(marmitonAdapter.locale).to.equal("fr");
|
|
});
|
|
|
|
describe("list", () => {
|
|
it("maps the search page's ItemList into RecipeSourceListItems and offers a next page", async () => {
|
|
stubFetchHtml(htmlWithItemListJsonLd([baseListItem]));
|
|
|
|
const result = await marmitonAdapter.list({ query: "tarte aux pommes" });
|
|
|
|
expect(result.items).to.deep.equal([
|
|
{
|
|
externalId: RECIPE_URL,
|
|
title: "Tarte aux pommes",
|
|
picture: "https://assets.afcdn.com/recipe/tarte.jpg",
|
|
url: RECIPE_URL,
|
|
},
|
|
]);
|
|
expect(result.nextCursor).to.equal("2");
|
|
});
|
|
|
|
it("requests the given cursor's page and stops offering a next page once a page comes back empty", async () => {
|
|
let requestedUrl: string | undefined;
|
|
globalThis.fetch = (async (url: string) => {
|
|
requestedUrl = url;
|
|
return new Response(htmlWithItemListJsonLd([]), { status: 200 });
|
|
}) as typeof fetch;
|
|
|
|
const result = await marmitonAdapter.list({ query: "tarte", cursor: "3" });
|
|
|
|
expect(requestedUrl).to.include("page=3");
|
|
expect(result.items).to.deep.equal([]);
|
|
expect(result.nextCursor).to.be.null;
|
|
});
|
|
|
|
it("treats a 404 (page past the last one) as an empty final page, not a failure", async () => {
|
|
stubFetchHtml("", 404);
|
|
|
|
const result = await marmitonAdapter.list({ query: "tarte", cursor: "999" });
|
|
|
|
expect(result.items).to.deep.equal([]);
|
|
expect(result.nextCursor).to.be.null;
|
|
});
|
|
|
|
it("skips a ListItem missing a url or a name", async () => {
|
|
stubFetchHtml(
|
|
htmlWithItemListJsonLd([
|
|
{ "@type": "ListItem", position: 1, name: "No url" },
|
|
{ "@type": "ListItem", position: 2, url: RECIPE_URL },
|
|
]),
|
|
);
|
|
|
|
const result = await marmitonAdapter.list({ query: "x" });
|
|
|
|
expect(result.items).to.deep.equal([]);
|
|
});
|
|
|
|
it("returns an empty page rather than throwing when the page has no ItemList at all", async () => {
|
|
stubFetchHtml("<!doctype html><html><body>Rien ici</body></html>");
|
|
|
|
const result = await marmitonAdapter.list({ query: "x" });
|
|
|
|
expect(result.items).to.deep.equal([]);
|
|
expect(result.nextCursor).to.be.null;
|
|
});
|
|
|
|
it("throws RecipeSourceFetchError on a non-2xx, non-404 response", async () => {
|
|
stubFetchHtml("", 500);
|
|
|
|
try {
|
|
await marmitonAdapter.list({ query: "x" });
|
|
expect.fail("expected list to throw");
|
|
} catch (err) {
|
|
expect(err).to.be.instanceOf(RecipeSourceFetchError);
|
|
}
|
|
});
|
|
|
|
it("throws RecipeSourceFetchError when the network request itself fails", async () => {
|
|
globalThis.fetch = (async () => {
|
|
throw new Error("network down");
|
|
}) as typeof fetch;
|
|
|
|
try {
|
|
await marmitonAdapter.list({ query: "x" });
|
|
expect.fail("expected list to throw");
|
|
} catch (err) {
|
|
expect(err).to.be.instanceOf(RecipeSourceFetchError);
|
|
expect((err as RecipeSourceFetchError).cause).to.be.instanceOf(Error);
|
|
}
|
|
});
|
|
});
|
|
|
|
describe("fetchDetail", () => {
|
|
it("fetches the given recipe URL and returns its html alongside the url", async () => {
|
|
stubFetchHtml(htmlWithRecipeJsonLd());
|
|
|
|
const result = await marmitonAdapter.fetchDetail(RECIPE_URL);
|
|
|
|
expect(result.url).to.equal(RECIPE_URL);
|
|
expect(result.html).to.include("Tarte aux pommes");
|
|
});
|
|
|
|
it("throws a RecipeSourceFetchError keyed to marmiton, not the underlying generic adapter", async () => {
|
|
stubFetchHtml("", 404);
|
|
|
|
try {
|
|
await marmitonAdapter.fetchDetail(RECIPE_URL);
|
|
expect.fail("expected fetchDetail to throw");
|
|
} catch (err) {
|
|
expect(err).to.be.instanceOf(RecipeSourceFetchError);
|
|
expect((err as RecipeSourceFetchError).sourceKey).to.equal("marmiton");
|
|
}
|
|
});
|
|
});
|
|
|
|
describe("parse", () => {
|
|
it("delegates to the generic JSON-LD parser end to end", () => {
|
|
const parsed = marmitonAdapter.parse({ html: htmlWithRecipeJsonLd(), url: RECIPE_URL });
|
|
|
|
expect(parsed.name).to.equal("Tarte aux pommes");
|
|
expect(parsed.portions).to.equal(6);
|
|
expect(parsed.sourceUrl).to.equal(RECIPE_URL);
|
|
expect(parsed.ingredients).to.deep.equal([
|
|
{ rawText: "3 pommes", quantity: null, unit: null, name: "3 pommes" },
|
|
{ rawText: "1 pâte brisée", quantity: null, unit: null, name: "1 pâte brisée" },
|
|
]);
|
|
expect(parsed.steps).to.deep.equal([
|
|
{ description: "Épluchez les pommes.", picture: null },
|
|
{ description: "Enfournez 30 minutes.", picture: null },
|
|
]);
|
|
});
|
|
|
|
it("throws a RecipeSourceParseError keyed to marmiton, not the underlying generic adapter", () => {
|
|
const html = "<!doctype html><html><body>Pas de JSON-LD ici</body></html>";
|
|
|
|
try {
|
|
marmitonAdapter.parse({ html, url: RECIPE_URL });
|
|
expect.fail("expected parse to throw");
|
|
} catch (err) {
|
|
expect(err).to.be.instanceOf(RecipeSourceParseError);
|
|
expect((err as RecipeSourceParseError).sourceKey).to.equal("marmiton");
|
|
}
|
|
});
|
|
});
|
|
});
|