contentoh-components-library 21.6.59 → 21.6.61

package/src/components/pages/ProductEdition/ServiceHeader.jsx

@@ -0,0 +1,104 @@
+import { Box, Button, Stack, Typography } from "@mui/material";
+import MenuIcon from "@mui/icons-material/Menu";
+
+import {
+  COLORS,
+  FONT_STACK,
+  TITLE_STACK,
+  ServiceIcon,
+  StatusChip,
+  serviceStatusProps,
+  outlineButtonSx,
+} from "../../organisms/ServicesNavigation/ui";
+import { groupLabel } from "../../organisms/ServicesNavigation/model";
+
+/*
+  Encabezado del servicio abierto. Ocupa el lugar de la barra de pestañas,
+  con el diseño de la propuesta de navegación por servicios:
+
+    [ícono]  GRUPO                     [equipo]            [herramientas]
+             Nombre del servicio [estatus]
+
+  - `team`: especialista, coordinador y auditor (sections/ServiceTeam).
+  - `children`: versión, guardar e imágenes (sections/ServiceTools).
+*/
+export const ServiceHeader = ({ service, isSummary, subtitle, onOpenRail, team, children }) => (
+  <Box
+    sx={{
+      display: "flex",
+      flexWrap: "wrap",
+      alignItems: "center",
+      columnGap: 2.5,
+      rowGap: 1.25,
+      pb: 1.5,
+      mb: 2,
+      borderBottom: `2px solid ${COLORS.s2}`,
+      minWidth: 0,
+    }}
+  >
+    {onOpenRail && (
+      <Button onClick={onOpenRail} startIcon={<MenuIcon sx={{ fontSize: 18 }} />} sx={outlineButtonSx}>
+        Servicios
+      </Button>
+    )}
+
+    <Stack direction="row" alignItems="center" spacing={1.25} sx={{ minWidth: 0, flex: "1 1 200px" }}>
+      <Box
+        sx={{
+          width: 40,
+          height: 40,
+          borderRadius: "10px",
+          bgcolor: COLORS.s2,
+          display: "flex",
+          alignItems: "center",
+          justifyContent: "center",
+          flexShrink: 0,
+        }}
+      >
+        <ServiceIcon icon={isSummary ? "summary" : service?.icon} sx={{ fontSize: 22, color: COLORS.magenta_s2 }} />
+      </Box>
+      <Box sx={{ minWidth: 0 }}>
+        <Typography
+          sx={{
+            fontFamily: FONT_STACK,
+            fontSize: 11,
+            fontWeight: 700,
+            letterSpacing: "0.06em",
+            textTransform: "uppercase",
+            color: COLORS.s4,
+          }}
+        >
+          {isSummary ? "Todos los servicios" : groupLabel(service?.group)}
+        </Typography>
+        <Stack direction="row" alignItems="center" spacing={1} sx={{ minWidth: 0 }}>
+          <Typography
+            component="h3"
+            sx={{
+              fontFamily: TITLE_STACK,
+              fontWeight: 500,
+              fontSize: 20,
+              lineHeight: "26px",
+              color: COLORS.s5,
+              overflow: "hidden",
+              textOverflow: "ellipsis",
+              whiteSpace: "nowrap",
+            }}
+          >
+            {isSummary ? "Resumen" : service?.display_name}
+          </Typography>
+          {!isSummary && service?.status && service.status !== "-" && (
+            <StatusChip {...serviceStatusProps(service)} oval />
+          )}
+        </Stack>
+      </Box>
+    </Stack>
+
+    {subtitle && (
+      <Typography sx={{ fontFamily: FONT_STACK, fontSize: 13, color: COLORS.s4 }}>{subtitle}</Typography>
+    )}
+
+    {team}
+
+    {children && <Box sx={{ ml: "auto", flexShrink: 0 }}>{children}</Box>}
+  </Box>
+);

package/src/components/pages/ProductEdition/api.js

@@ -0,0 +1,84 @@
+import axios from "axios";
+
+/*
+  Servicios del producto en el backend (Lambda `product-services`, ver
+  CRUD/services/docs/product-services.md en content-management-backend):
+
+    GET /product-services?articleId=&orderId=   servicios, estatus, equipo y acciones
+    PUT /product-services/set-status            estatus de un servicio de flujo simple
+    PUT /product-services/assign                especialista o coordinador
+    GET /service-catalog?view=assignables       a quién se puede asignar un rol
+
+  Las URL salen de REACT_APP_PRODUCT_SERVICES_ENDPOINT y
+  REACT_APP_SERVICE_CATALOG_ENDPOINT o, si no están, de
+  REACT_APP_SERVICES_ENDPOINT cambiando /services por la ruta nueva (mismo
+  API Gateway).
+*/
+
+const fromServicesEndpoint = (path) => {
+  const services = process.env.REACT_APP_SERVICES_ENDPOINT;
+  return services ? services.replace(/\/services\/?$/, path) : null;
+};
+
+export const productServicesUrl = () =>
+  process.env.REACT_APP_PRODUCT_SERVICES_ENDPOINT || fromServicesEndpoint("/product-services");
+
+const serviceCatalogUrl = () =>
+  process.env.REACT_APP_SERVICE_CATALOG_ENDPOINT || fromServicesEndpoint("/service-catalog");
+
+/** Error con el mensaje del backend, para mostrarlo tal cual. */
+export class ProductServicesError extends Error {
+  constructor(message, status, detail) {
+    super(message);
+    this.name = "ProductServicesError";
+    this.status = status;
+    this.detail = detail;
+  }
+}
+
+/*
+  Las Lambdas usan `integration: lambda`: API Gateway responde 200 y el
+  código real viene en `data.statusCode`, con el cuerpo como texto en
+  `data.body`.
+*/
+const unwrap = (response) => {
+  const data = response?.data ?? {};
+  const body = typeof data.body === "string" ? JSON.parse(data.body) : data.body ?? data;
+  const status = Number(data.statusCode ?? response?.status ?? 200);
+  if (status >= 400) {
+    throw new ProductServicesError(body?.message ?? "Error en los servicios del producto", status, body?.detail);
+  }
+  return body;
+};
+
+export const fetchProductServices = async ({ articleId, orderId, token }) => {
+  const url = productServicesUrl();
+  if (!url) throw new ProductServicesError("Falta REACT_APP_SERVICES_ENDPOINT", 0);
+  const response = await axios.get(url, {
+    params: { articleId, orderId },
+    headers: { Authorization: token },
+  });
+  return unwrap(response);
+};
+
+const putAction = async (action, data, token) => {
+  const response = await axios.put(`${productServicesUrl()}/${action}`, data, {
+    headers: { Authorization: token },
+  });
+  return unwrap(response);
+};
+
+export const setServiceStatus = ({ articleId, orderId, serviceName, statusName, retailerIds, token }) =>
+  putAction("set-status", { articleId, orderId, serviceName, statusName, retailerIds }, token);
+
+export const assignService = ({ articleId, orderId, serviceName, role, userId, token }) =>
+  putAction("assign", { articleId, orderId, serviceName, role, userId }, token);
+
+/** Personas que pueden ocupar el rol del servicio. */
+export const fetchAssignables = async ({ serviceName, role, token }) => {
+  const response = await axios.get(serviceCatalogUrl(), {
+    params: { view: "assignables", service_name: serviceName, assignment_role: role },
+    headers: { Authorization: token },
+  });
+  return unwrap(response)?.users ?? [];
+};

package/src/components/pages/ProductEdition/index.js

@@ -0,0 +1,21 @@
+import { ProviderProductEditionProvider } from "../RetailerProductEdition/context/provider-product-edition.context";
+import { ProductEditionView } from "./ProductEditionView";
+
+/**
+ * Edición de producto unificada: una sola pantalla para Creators y para
+ * Content Management, con la lista lateral de servicios. Lo que cambia entre
+ * aplicaciones son los permisos (`permissions.js`).
+ *
+ * Props: las de CreatorsProductEdition (`tabsSections`, `productSelected`,
+ * `user`, `token`, `location`, `enableDigitalAssets`) y además:
+ *   - `app`: "creators" (fase 1). "management" llega en la fase 2.
+ *   - `demoServices`: solo para historias de Storybook.
+ *
+ * Los servicios salen de GET /product-services; si no responde, la lista
+ * muestra los servicios de siempre del producto.
+ */
+export const ProductEdition = (props) => (
+  <ProviderProductEditionProvider>
+    <ProductEditionView {...props} />
+  </ProviderProductEditionProvider>
+);

package/src/components/pages/ProductEdition/permissions.js

@@ -0,0 +1,128 @@
+/*
+  Permisos de la edición de producto, en un solo lugar.
+
+  Antes estas reglas vivían repartidas en `if` dentro de cada vista
+  (RetailerProductEdition, ProviderProductEdition y la copia del hook de
+  CreatorsProductEdition). Aquí son funciones puras: reciben el producto, la
+  persona y el servicio, y responden sí o no. Así se pueden leer como una tabla
+  y probar sin montar la pantalla.
+
+  FASE 1 — app «creators» (equipo Content-oh). Las reglas son las mismas que
+  usa hoy `useCreatorsProductEdition`, copiadas tal cual:
+
+    Rol 1  Administrador          todo
+    Rol 4  Coordinador de textos  evalúa lo que está en IE (información enviada)
+    Rol 5  Coordinador de imágenes evalúa lo que está en IE
+    Rol 6  Auditor                evalúa lo que está en AC, RP, RCA, SAC
+    Rol 7  Especialista de textos produce; también valida lo que está en AC
+    Rol 8  Especialista de imágenes produce; también valida lo que está en AC
+
+  Además del rol cuenta la ASIGNACIÓN del producto: `id_<servicio>_especialist`,
+  `id_<servicio>_facilitator` (coordinador) e `id_auditor`. Quien está asignado
+  a un servicio puede trabajarlo aunque su rol sea otro.
+
+  FASE 2 — app «management» (proveedor y cadena) se agrega aquí mismo.
+*/
+
+/** Servicios que hoy tienen editor y su pestaña en la edición. */
+export const CLASSIC_SERVICES = [
+  { service_name: "datasheet", tab: "Ficha técnica" },
+  { service_name: "description", tab: "Descripción" },
+  { service_name: "images", tab: "Imágenes" },
+];
+
+export const tabOf = (serviceName) =>
+  CLASSIC_SERVICES.find((item) => item.service_name === serviceName)?.tab ?? null;
+
+export const serviceOfTab = (tab) =>
+  CLASSIC_SERVICES.find((item) => item.tab === tab)?.service_name ?? null;
+
+/** Estatus base: «RA/AS» → «AS» (la parte vigente es la última). */
+export const currentStatus = (status) => String(status ?? "").replace(/.*\//, "");
+
+const roleOf = (user) => Number(user?.id_role);
+
+export const isAdmin = (user) => roleOf(user) === 1;
+
+export const isAssignedAs = (product, user, role, serviceName) => {
+  const assigned = product?.[`id_${serviceName}_${role}`];
+  return Boolean(assigned) && assigned === user?.id_user;
+};
+
+export const isAuditorAssigned = (product, user) =>
+  Boolean(product?.id_auditor) && product.id_auditor === user?.id_user;
+
+/**
+ * Trabaja el servicio: administrador, o especialista/coordinador asignado con
+ * un rol del equipo. Igual que `isUserAssignedToService` del hook.
+ */
+export const isAssignedToService = (product, user, serviceName, role) => {
+  if (![1, 4, 5, 6, 7, 8].includes(roleOf(user))) return false;
+  if (isAdmin(user)) return true;
+  return role
+    ? isAssignedAs(product, user, role, serviceName)
+    : isAssignedAs(product, user, "especialist", serviceName) ||
+        isAssignedAs(product, user, "facilitator", serviceName);
+};
+
+/** Ve el botón de guardar: el auditor asignado o quien trabaja el servicio. */
+export const canSave = (product, user, serviceName) =>
+  isAuditorAssigned(product, user) || isAssignedToService(product, user, serviceName);
+
+/** Puede asignar personas: todos menos los especialistas (roles 7 y 8). */
+export const canAssign = (user) => ![7, 8].includes(roleOf(user));
+
+/** Envía su trabajo al coordinador: los especialistas. */
+export const canSendToFacilitator = (user) => [7, 8].includes(roleOf(user));
+
+/** Ve «Cambio de estatus»: una lista fija de cuentas (constants.js). */
+export const canChangeStatus = (user, allowedAccounts = []) => allowedAccounts.includes(user?.email);
+
+/**
+ * Puede validar o rechazar el servicio en la cadena activa. Misma regla que
+ * `canShowSingleEvaluationButtons` del hook.
+ */
+export const canEvaluate = (product, user, serviceName, retailerStatus) => {
+  const status = currentStatus(retailerStatus);
+  const role = roleOf(user);
+  const asFacilitator =
+    status === "IE" && ([1, 4, 5].includes(role) || isAssignedAs(product, user, "facilitator", serviceName));
+  const asAuditor =
+    ["AC", "RP", "RCA", "SAC"].includes(status) && ([1, 6].includes(role) || isAuditorAssigned(product, user));
+  const asSpecialist = status === "AC" && [7, 8].includes(role);
+  return asFacilitator || asAuditor || asSpecialist;
+};
+
+/* ------------------------------------------------------------------------ */
+/* Lista lateral                                                            */
+/* ------------------------------------------------------------------------ */
+
+/*
+  «Te toca a ti»: el estatus del servicio está en una etapa que le
+  corresponde a alguno de los papeles que la persona tiene asignados en él.
+  Un estatus compuesto («RA/AS») cuenta por cualquiera de sus partes.
+
+    especialista  asignado, capturando o rechazado por coordinador/auditor
+    coordinador   por asignar o con información enviada (IE) para revisar
+    auditor       lo mismo que puede evaluar: AC, RP, RCA, SAC
+*/
+const ACTIONABLE = {
+  especialist: ["AS", "CA", "RC", "RA"],
+  facilitator: ["PA", "IE"],
+  auditor: ["AC", "RP", "RCA", "SAC"],
+};
+
+export const rolesInService = (product, user, serviceName) => {
+  const roles = [];
+  if (isAssignedAs(product, user, "especialist", serviceName)) roles.push("especialist");
+  if (isAssignedAs(product, user, "facilitator", serviceName)) roles.push("facilitator");
+  if (isAuditorAssigned(product, user)) roles.push("auditor");
+  return roles;
+};
+
+export const isPendingFor = (product, user, serviceName, status) => {
+  const parts = String(status ?? "").split("/");
+  return rolesInService(product, user, serviceName).some((role) =>
+    parts.some((part) => ACTIONABLE[role].includes(part))
+  );
+};

package/src/components/pages/ProductEdition/permissions.test.js

@@ -0,0 +1,249 @@
+/**
+ * Matriz de permisos de la edición (fase 1, app «creators»).
+ *
+ * La librería no tiene corredor de pruebas propio; se corre con
+ *   npx vitest run src/components/pages/ProductEdition
+ *
+ * Cada caso fija una regla tal como funciona hoy en
+ * `useCreatorsProductEdition`: si una prueba falla, cambió quién puede hacer
+ * qué, y eso hay que decidirlo a propósito.
+ */
+import { describe, expect, it } from "vitest";
+import {
+  canAssign,
+  canChangeStatus,
+  canEvaluate,
+  canSave,
+  canSendToFacilitator,
+  currentStatus,
+  isAssignedToService,
+  isPendingFor,
+  serviceOfTab,
+  tabOf,
+} from "./permissions";
+import { buildEditionServices } from "./services";
+
+const product = {
+  datasheet_status: "AS",
+  description_status: "RA/AS",
+  images_status: "NS",
+  id_datasheet_especialist: 426,
+  id_datasheet_facilitator: 430,
+  id_description_especialist: 426,
+  id_description_facilitator: 430,
+  id_images_especialist: 427,
+  id_auditor: 425,
+};
+
+const user = (id_user, id_role, extra = {}) => ({ id_user, id_role, ...extra });
+const admin = user(1, 1);
+const textSpecialist = user(426, 7);
+const imageSpecialist = user(427, 8);
+const coordinator = user(430, 4);
+const unassignedCoordinator = user(431, 5);
+const auditor = user(425, 6);
+const unassignedAuditor = user(432, 6);
+
+describe("pestañas y estatus", () => {
+  it("relaciona servicio y pestaña en los dos sentidos", () => {
+    expect(tabOf("datasheet")).toBe("Ficha técnica");
+    expect(serviceOfTab("Imágenes")).toBe("images");
+    expect(tabOf("translation")).toBeNull();
+  });
+
+  it("toma la parte vigente de un estatus compuesto", () => {
+    expect(currentStatus("RA/AS")).toBe("AS");
+    expect(currentStatus("AC")).toBe("AC");
+    expect(currentStatus(null)).toBe("");
+  });
+});
+
+describe("trabajar y guardar un servicio", () => {
+  it("el administrador puede en todos", () => {
+    expect(canSave(product, admin, "images")).toBe(true);
+  });
+
+  it("el especialista solo en los servicios que tiene asignados", () => {
+    expect(canSave(product, textSpecialist, "datasheet")).toBe(true);
+    expect(canSave(product, textSpecialist, "images")).toBe(false);
+    expect(canSave(product, imageSpecialist, "images")).toBe(true);
+  });
+
+  it("el coordinador asignado puede; el que no está asignado, no", () => {
+    expect(canSave(product, coordinator, "description")).toBe(true);
+    expect(canSave(product, unassignedCoordinator, "description")).toBe(false);
+  });
+
+  it("el auditor asignado al producto puede en todos sus servicios", () => {
+    expect(canSave(product, auditor, "images")).toBe(true);
+    expect(canSave(product, unassignedAuditor, "images")).toBe(false);
+  });
+
+  it("un rol fuera del equipo no trabaja servicios aunque coincida el id", () => {
+    expect(isAssignedToService(product, user(426, 3), "datasheet")).toBe(false);
+  });
+});
+
+describe("asignar, enviar al coordinador y cambiar estatus", () => {
+  it("asignan todos menos los especialistas", () => {
+    expect(canAssign(admin)).toBe(true);
+    expect(canAssign(coordinator)).toBe(true);
+    expect(canAssign(auditor)).toBe(true);
+    expect(canAssign(textSpecialist)).toBe(false);
+    expect(canAssign(imageSpecialist)).toBe(false);
+  });
+
+  it("envían al coordinador solo los especialistas", () => {
+    expect(canSendToFacilitator(textSpecialist)).toBe(true);
+    expect(canSendToFacilitator(coordinator)).toBe(false);
+  });
+
+  it("«Cambio de estatus» depende de la lista de cuentas", () => {
+    const allowed = ["oserna@contentoh.com"];
+    expect(canChangeStatus(user(1, 1, { email: "oserna@contentoh.com" }), allowed)).toBe(true);
+    expect(canChangeStatus(user(1, 1, { email: "otra@contentoh.com" }), allowed)).toBe(false);
+  });
+});
+
+describe("validar o rechazar en la cadena activa", () => {
+  it("IE: coordinadores por rol o el coordinador asignado", () => {
+    expect(canEvaluate(product, unassignedCoordinator, "datasheet", "IE")).toBe(true);
+    expect(canEvaluate(product, admin, "datasheet", "IE")).toBe(true);
+    expect(canEvaluate(product, auditor, "datasheet", "IE")).toBe(false);
+    expect(canEvaluate(product, textSpecialist, "datasheet", "IE")).toBe(false);
+  });
+
+  it("AC, RP, RCA y SAC: auditor por rol o asignado", () => {
+    ["AC", "RP", "RCA", "SAC"].forEach((status) => {
+      expect(canEvaluate(product, unassignedAuditor, "images", status)).toBe(true);
+    });
+    expect(canEvaluate(product, coordinator, "images", "RP")).toBe(false);
+  });
+
+  it("AC: también los especialistas", () => {
+    expect(canEvaluate(product, textSpecialist, "datasheet", "AC")).toBe(true);
+    expect(canEvaluate(product, imageSpecialist, "images", "AC")).toBe(true);
+  });
+
+  it("en captura nadie evalúa, salvo que la parte vigente lo permita", () => {
+    expect(canEvaluate(product, admin, "datasheet", "CA")).toBe(false);
+    expect(canEvaluate(product, auditor, "datasheet", "RA/AC")).toBe(true);
+  });
+});
+
+describe("«te toca a ti» en la lista lateral", () => {
+  it("al especialista le toca lo asignado, en captura o rechazado", () => {
+    expect(isPendingFor(product, textSpecialist, "datasheet", "AS")).toBe(true);
+    expect(isPendingFor(product, textSpecialist, "description", "RA/AS")).toBe(true);
+    expect(isPendingFor(product, textSpecialist, "datasheet", "AC")).toBe(false);
+  });
+
+  it("al coordinador asignado, lo que está por asignar o en IE", () => {
+    expect(isPendingFor(product, coordinator, "datasheet", "IE")).toBe(true);
+    expect(isPendingFor(product, coordinator, "datasheet", "CA")).toBe(false);
+  });
+
+  it("al auditor asignado, lo que puede evaluar", () => {
+    expect(isPendingFor(product, auditor, "images", "AC")).toBe(true);
+    expect(isPendingFor(product, auditor, "images", "AS")).toBe(false);
+  });
+
+  it("a quien no está asignado nunca le toca, aunque su rol pueda evaluar", () => {
+    expect(isPendingFor(product, unassignedAuditor, "images", "AC")).toBe(false);
+  });
+});
+
+describe("servicios de la lista lateral", () => {
+  const servicesData = [
+    { service: "datasheet", id_retailer: 4, status: "CA" },
+    { service: "datasheet", id_retailer: 9, status: "AC" },
+  ];
+
+  it("solo aparecen los servicios contratados", () => {
+    const services = buildEditionServices({ product, user: textSpecialist, servicesData, activeRetailerId: 4 });
+    expect(services.map((item) => item.service_name)).toEqual(["datasheet", "description"]);
+  });
+
+  it("el estatus es el de la cadena activa, con el del producto de respaldo", () => {
+    const at4 = buildEditionServices({ product, user: textSpecialist, servicesData, activeRetailerId: 4 });
+    const at9 = buildEditionServices({ product, user: textSpecialist, servicesData, activeRetailerId: 9 });
+    expect(at4[0].status).toBe("CA");
+    expect(at9[0].status).toBe("AC");
+    expect(at4[1].status).toBe("RA/AS");
+  });
+
+  it("marca los servicios de la persona y lo que le toca", () => {
+    const services = buildEditionServices({ product, user: imageSpecialist, servicesData, activeRetailerId: 4 });
+    expect(services.every((item) => item.mine === false)).toBe(true);
+    const mine = buildEditionServices({ product, user: textSpecialist, servicesData, activeRetailerId: 4 });
+    expect(mine.map((item) => [item.mine, item.pending])).toEqual([
+      [true, true],
+      [true, true],
+    ]);
+  });
+
+  it("agrega los servicios de ejemplo al final, marcados como tales", () => {
+    const services = buildEditionServices({
+      product,
+      user: admin,
+      servicesData,
+      activeRetailerId: 4,
+      demoServices: [{ service_name: "translation", status: "CA" }],
+    });
+    const demo = services[services.length - 1];
+    expect(demo).toMatchObject({ service_name: "translation", display_name: "Traducción", is_demo: true, tab: null });
+  });
+
+  it("ignora los servicios de muestra que traiga el producto (?demoServicios=1)", () => {
+    const services = buildEditionServices({
+      product: { ...product, demo_services: [{ service_name: "seo", status: "AS" }] },
+      user: admin,
+      servicesData,
+      activeRetailerId: 4,
+    });
+    expect(services.some((item) => item.is_demo)).toBe(false);
+  });
+
+  it("los de ejemplo son del auditor del producto y de nadie más", () => {
+    const demoServices = [{ service_name: "seo", status: "AS" }];
+    const forAuditor = buildEditionServices({ product, user: auditor, servicesData, demoServices });
+    const forSpecialist = buildEditionServices({ product, user: textSpecialist, servicesData, demoServices });
+    expect(forAuditor.every((item) => item.mine)).toBe(true);
+    expect(forAuditor.at(-1).assignees.auditor).toMatchObject({ id_user: 425 });
+    expect(forSpecialist.at(-1).mine).toBe(false);
+  });
+
+  it("sin producto no hay servicios", () => {
+    expect(buildEditionServices({ product: null, user: admin })).toEqual([]);
+  });
+});
+
+describe("servicios mientras carga la edición", () => {
+  it("no truena con services_data y asignaciones en null", () => {
+    const services = buildEditionServices({
+      product,
+      user: textSpecialist,
+      servicesData: null,
+      activeRetailerId: undefined,
+      collaboratorAssignations: null,
+    });
+    expect(services.map((item) => item.status)).toEqual(["AS", "RA/AS"]);
+  });
+});
+
+describe("equipo del servicio", () => {
+  it("le pone nombre al auditor con la lista de auditores", () => {
+    const [first] = buildEditionServices({
+      product,
+      user: textSpecialist,
+      servicesData: [],
+      auditors: [{ id_user: 425, name: "Auditor QA", last_name: null }],
+    });
+    expect(first.assignees.auditor).toMatchObject({ id_user: 425, name: "Auditor QA" });
+  });
+
+  it("sin la lista, el auditor queda como «Asignado»", () => {
+    const [first] = buildEditionServices({ product, user: textSpecialist, servicesData: [] });
+    expect(first.assignees.auditor).toMatchObject({ id_user: 425, name: "Asignado" });
+  });
+});