Skip to content

The easy-to-use open source Business Intelligence and Embedded Analytics tool that lets everyone work with data :bar_chart:

5.8 KB
Raw Blame
import fetchMock from "fetch-mock";

import { getQuestionVirtualTableId } from "metabase-lib/v1/metadata/utils/saved-questions";
import type {
  Card,
  CardId,
  CardQueryMetadata,
  ConcreteTableId,
  DashboardId,
  Dataset,
  FieldValue,
  GetPublicCard,
  ParameterId,
  ParameterValues,
} from "metabase-types/api";
import { createMockCard } from "metabase-types/api/mocks";

import { PERMISSION_ERROR } from "./constants";

export function setupCardEndpoints(card: Card) {
  fetchMock.get(`path:/api/card/${card.id}`, card, {
    name: `card-${card.id}-get`,
  });
  fetchMock.put(
    `path:/api/card/${card.id}`,
    async (call) => {
      const lastCall = fetchMock.callHistory.lastCall(call.url);
      return createMockCard(await lastCall?.request?.json());
    },
    { name: `card-${card.id}-put` },
  );
  fetchMock.get(`path:/api/card/${card.id}/series`, [], {
    name: `card-${card.id}-series`,
  });
}

export function setupDeleteCardEndpoint(cardId: CardId) {
  fetchMock.delete(`path:/api/card/${cardId}`, 204);
}

export function setupUpdateCardEndpointWithError(cardId: CardId) {
  fetchMock.put(`path:/api/card/${cardId}`, { status: 500, body: {} });
}

export function setupCardByEntityIdEndpoints(card: Card) {
  fetchMock.get(`path:/api/card/${card.entity_id}`, card, {
    name: `card-entity-${card.entity_id}-get`,
  });
  fetchMock.put(
    `path:/api/card/${card.entity_id}`,
    async (call) => {
      const lastCall = fetchMock.callHistory.lastCall(call.url);
      return createMockCard(await lastCall?.request?.json());
    },
    { name: `card-entity-${card.entity_id}-put` },
  );
  fetchMock.get(`path:/api/card/${card.entity_id}/series`, [], {
    name: `card-entity-${card.entity_id}-series`,
  });
}

export function setupCardQueryMetadataEndpoint(
  card: Card,
  metadata: CardQueryMetadata,
) {
  fetchMock.get(`path:/api/card/${card.id}/query_metadata`, metadata, {
    name: `card-${card.id}-query-metadata`,
  });
}

export function setupCardsEndpoints(cards: Card[]) {
  fetchMock.get({
    url: "path:/api/card",
    response: cards,
    name: "cards-list",
  });
  setupCardCreateEndpoint();
  cards.forEach((card) => setupCardEndpoints(card));
}

export function setupCardsUsingModelEndpoint(card: Card, usedBy: Card[] = []) {
  fetchMock.get({
    url: "path:/api/card",
    query: { f: "using_model", model_id: card.id },
    response: usedBy,
  });
}

export function setupCardsForTableEndpoint(
  tableId: ConcreteTableId,
  cards: Card[] = [],
) {
  fetchMock.get({
    url: "path:/api/card",
    query: { f: "table", model_id: tableId },
    response: cards,
  });
}

export function setupCardCreateEndpoint() {
  fetchMock.post(
    "path:/api/card",
    async (call) => {
      const lastCall = fetchMock.callHistory.lastCall(call.url);
      return createMockCard(await lastCall?.request?.json());
    },
    { name: "card-create" },
  );
}

export function setupUnauthorizedCardEndpoints(card: Card) {
  fetchMock.get(`path:/api/card/${card.id}`, {
    status: 403,
    body: PERMISSION_ERROR,
  });

  const virtualTableId = getQuestionVirtualTableId(card.id);
  fetchMock.get(`path:/api/table/${virtualTableId}/query_metadata`, {
    status: 403,
    body: PERMISSION_ERROR,
  });
}

export function setupUnauthorizedCardsEndpoints(cards: Card[]) {
  cards.forEach((card) => setupUnauthorizedCardEndpoints(card));
}

/**
 * Makes the card's own endpoints (the card, its query metadata, and running its
 * query) all return 403, i.e. a card the current user has no access to at all.
 */
export function setupForbiddenCardEndpoints(cardId: CardId) {
  fetchMock.get(`path:/api/card/${cardId}`, {
    status: 403,
    body: PERMISSION_ERROR,
  });
  fetchMock.get(`path:/api/card/${cardId}/query_metadata`, {
    status: 403,
    body: PERMISSION_ERROR,
  });
  fetchMock.post(`path:/api/card/${cardId}/query`, {
    status: 403,
    body: PERMISSION_ERROR,
  });
}

export function setupCardQueryEndpoints(card: Card, dataset: Dataset) {
  fetchMock.post(`path:/api/card/${card.id}/query`, dataset);
}

export function setupCardQueryDownloadEndpoint(card: Card, type: string) {
  fetchMock.post(`path:/api/card/${card.id}/query/${type}`, {});
}

export function setupCardPublicLinkEndpoints(cardId: CardId) {
  fetchMock.post(`path:/api/card/${cardId}/public_link`, {
    id: cardId,
    uuid: "mock-uuid",
  });
  fetchMock.delete(`path:/api/card/${cardId}/public_link`, {
    id: cardId,
  });
}

export function setupListPublicCardsEndpoint(publicCards: GetPublicCard[]) {
  fetchMock.get("path:/api/card/public", publicCards);
}

export function setupCardDashboardsEndpoint(
  cardId: CardId,
  dashboards: { id: DashboardId; name: string; enable_embedding: boolean }[],
) {
  fetchMock.get(`path:/api/card/${cardId}/dashboards`, dashboards, {
    name: `card-${cardId}-dashboards`,
  });
}

export function setupCardParameterValuesEndpoint({
  cardId,
  parameterId,
  parameterValues,
}: {
  cardId: CardId;
  parameterId: ParameterId;
  parameterValues: ParameterValues;
}) {
  fetchMock.get(
    `path:/api/card/${cardId}/params/${parameterId}/values`,
    parameterValues,
  );
}

export function setupCardParameterRemappingEndpoint({
  cardId,
  parameterId,
  remappings,
}: {
  cardId: CardId;
  parameterId: ParameterId;
  remappings: FieldValue[];
}) {
  fetchMock.get(
    `path:/api/card/${cardId}/params/${parameterId}/remapping`,
    ({ url }) => {
      const value = new URL(url).searchParams.get("value");
      return (
        remappings.find(
          ([remappedValue]) => String(remappedValue) === value,
        ) ?? [value]
      );
    },
  );
}

export function setupCardParameterSearchEndpoint({
  cardId,
  parameterId,
  query,
  parameterValues,
}: {
  cardId: CardId;
  parameterId: ParameterId;
  query: string;
  parameterValues: ParameterValues;
}) {
  fetchMock.get(
    `path:/api/card/${cardId}/params/${parameterId}/search/${encodeURIComponent(query)}`,
    parameterValues,
  );
}