Skip to content

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

25.6 KB
Raw Blame
import { createMockMetadata } from "__support__/metadata";
import { checkNotNull } from "metabase/utils/types";
import {
  createMockColumn,
  createMockDatasetData,
  createMockField,
  createMockParameter,
} from "metabase-types/api/mocks";
import {
  ORDERS,
  ORDERS_ID,
  PRODUCTS,
  PRODUCTS_ID,
  SAMPLE_DB_ID,
  createOrdersCreatedAtField,
  createOrdersDiscountField,
  createOrdersIdField,
  createOrdersProductIdField,
  createOrdersQuantityField,
  createOrdersSubtotalField,
  createOrdersTable,
  createOrdersTaxField,
  createOrdersTotalField,
  createOrdersUserIdField,
  createPeopleTable,
  createProductsTable,
  createReviewsTable,
  createSampleDatabase,
} from "metabase-types/api/mocks/presets";

import Question from "./Question";
import NativeQuery from "./queries/NativeQuery";

const metadata = createMockMetadata({
  databases: [createSampleDatabase()],
});

const metadata_without_order_pk = createMockMetadata({
  databases: [
    createSampleDatabase({
      tables: [
        createProductsTable(),
        createPeopleTable(),
        createReviewsTable(),
        createOrdersTable({
          fields: [
            createOrdersIdField({ semantic_type: "type/Integer" }),
            createOrdersUserIdField(),
            createOrdersProductIdField(),
            createOrdersSubtotalField(),
            createOrdersTaxField(),
            createOrdersTotalField(),
            createOrdersDiscountField(),
            createOrdersCreatedAtField(),
            createOrdersQuantityField(),
          ],
        }),
      ],
    }),
  ],
});

const card = {
  display: "table",
  visualization_settings: {},
  dataset_query: {
    type: "query",
    database: SAMPLE_DB_ID,
    query: {
      "source-table": ORDERS_ID,
    },
  },
};
const base_question = new Question(card, metadata);

const orders_raw_card = {
  id: 1,
  name: "Raw orders data",
  display: "table",
  visualization_settings: {},
  can_write: true,
  dataset_query: {
    type: "query",
    database: SAMPLE_DB_ID,
    query: {
      "source-table": ORDERS_ID,
    },
  },
};
const orders_raw_question = new Question(orders_raw_card, metadata);

const orders_card_without_pk = {
  id: 1,
  name: "Orders Model",
  display: "table",
  visualization_settings: {},
  can_write: true,
  type: "model",
  database_id: SAMPLE_DB_ID,
  table_id: ORDERS_ID,
  dataset_query: {
    type: "query",
    database: SAMPLE_DB_ID,
    query: {
      "source-table": ORDERS_ID,
    },
  },
  result_metadata: [
    createOrdersIdField({
      semantic_type: "type/Integer",
      field_ref: ["field", 11, null],
    }),
  ],
};

const orders_count_card = {
  id: 2,
  name: "# orders data",
  display: "table",
  visualization_settings: {},
  dataset_query: {
    type: "query",
    database: SAMPLE_DB_ID,
    query: {
      "source-table": ORDERS_ID,
      aggregation: [["count"]],
    },
  },
};
const orders_count_question = new Question(orders_count_card, metadata);
const ordersCountData = createMockDatasetData({
  cols: [
    createMockColumn({
      name: "count",
      display_name: "Count",
      base_type: "type/BigInteger",
      semantic_type: "type/Quantity",
      effective_type: "type/BigInteger",
    }),
  ],
  rows: [[1]],
});

const multipleRowsData = createMockDatasetData({
  cols: [
    createMockColumn({ display_name: "foo" }),
    createMockColumn({ display_name: "bar" }),
  ],
  rows: [
    [10, 20],
    [100, 200],
  ],
});

const orders_filter_card = {
  id: 2,
  name: "# orders data",
  display: "line",
  dataset_query: {
    type: "query",
    database: SAMPLE_DB_ID,
    query: {
      "source-table": ORDERS_ID,
      filter: [">", ["field", ORDERS.TOTAL, null], 10],
    },
  },
};

const orders_join_card = {
  id: 2,
  name: "# orders data",
  display: "line",
  dataset_query: {
    type: "query",
    database: SAMPLE_DB_ID,
    query: {
      "source-table": ORDERS_ID,
      joins: [
        {
          fields: "all",
          "source-table": PRODUCTS_ID,
          condition: [
            "=",
            ["field-id", ORDERS.PRODUCT_ID],
            ["joined-field", "Products", ["field-id", PRODUCTS.ID]],
          ],
          alias: "Products",
        },
      ],
    },
  },
};

const orders_expression_card = {
  id: 2,
  name: "# orders data",
  display: "line",
  dataset_query: {
    type: "query",
    database: SAMPLE_DB_ID,
    query: {
      "source-table": ORDERS_ID,
      expressions: { double_total: ["+", 1, 1] },
    },
  },
};

const orders_multi_stage_card = {
  id: 2,
  name: "# orders data",
  display: "line",
  dataset_query: {
    type: "query",
    database: SAMPLE_DB_ID,
    query: {
      "source-query": {
        "source-table": ORDERS_ID,
        filter: [">", ["field", ORDERS.TOTAL, null], 10],
        aggregation: [["count"]],
        breakout: [["field", ORDERS.CREATED_AT, { "temporal-unit": "month" }]],
      },
      filter: [">", ["field", "count", { "base-type": "type/Integer" }], 20],
    },
  },
};

const native_orders_count_card = {
  id: 3,
  name: "# orders data",
  display: "table",
  visualization_settings: {},
  dataset_query: {
    type: "native",
    database: SAMPLE_DB_ID,
    native: {
      query: "SELECT count(*) FROM orders",
    },
  },
};
const native_orders_count_question = new Question(
  native_orders_count_card,
  metadata,
);

const orders_count_by_id_card = {
  id: 2,
  name: "# orders data",
  can_write: false,
  display: "table",
  visualization_settings: {},
  dataset_query: {
    type: "query",
    database: SAMPLE_DB_ID,
    query: {
      "source-table": ORDERS_ID,
      aggregation: [["count"]],
      breakout: [["field", ORDERS.ID, null]],
    },
  },
};

const orders_count_by_id_question = new Question(
  orders_count_by_id_card,
  metadata,
);

describe("Question", () => {
  describe("CREATED WITH", () => {
    describe("new Question(alreadyDefinedCard, metadata)", () => {
      it("has an id", () => {
        expect(orders_raw_question.id()).toBe(orders_raw_card.id);
      });

      it("has a name", () => {
        expect(orders_raw_question.displayName()).toBe(orders_raw_card.name);
      });

      it("is runnable", () => {
        expect(orders_raw_question.canRun()).toBe(true);
      });

      it("has correct display settings", () => {
        expect(orders_raw_question.display()).toBe("table");
      });
    });

    describe("Question.create(...)", () => {
      const question = Question.create({
        metadata,
        DEPRECATED_RAW_MBQL_databaseId: SAMPLE_DB_ID,
        DEPRECATED_RAW_MBQL_tableId: ORDERS_ID,
      });

      it("defaults to table display", () => {
        expect(question.display()).toEqual("table");
      });
    });
  });

  describe("STATUS METHODS", () => {
    describe("canRun()", () => {
      it("You should be able to run a newly created query", () => {
        expect(orders_raw_question.canRun()).toBe(true);
      });
    });

    describe("canWrite()", () => {
      it("You should be able to write to a question you have permissions to", () => {
        expect(orders_raw_question.canWrite()).toBe(true);
      });

      it("You should not be able to write to a question you don't have permissions to", () => {
        expect(orders_count_by_id_question.canWrite()).toBe(false);
      });
    });

    describe("isSaved()", () => {
      it("A newly created query doesn't have an id and shouldn't be marked as isSaved()", () => {
        expect(base_question.isSaved()).toBe(false);
      });

      it("A saved question does have an id and should be marked as isSaved()", () => {
        expect(orders_raw_question.isSaved()).toBe(true);
      });
    });
  });

  describe("At the heart of a question is an MBQL query.", () => {
    describe("legacyNativeQuery()", () => {
      it("returns a correct class instance for structured query", () => {
        expect(orders_raw_question.legacyNativeQuery()).toBeUndefined();
      });

      it("returns a correct class instance for native query", () => {
        const query = native_orders_count_question.legacyNativeQuery();
        expect(query instanceof NativeQuery).toBe(true);
      });
    });

    describe("setQuery(query)", () => {
      it("updates the dataset_query of card", () => {
        const rawQuery = checkNotNull(
          native_orders_count_question.legacyNativeQuery(),
        );
        const newRawQuestion = orders_raw_question.setLegacyQuery(rawQuery);
        expect(newRawQuestion.legacyNativeQuery() instanceof NativeQuery).toBe(
          true,
        );
      });
    });

    describe("setDatasetQuery(datasetQuery)", () => {
      it("updates the dataset_query of card", () => {
        const rawQuestion = orders_raw_question.setDatasetQuery(
          native_orders_count_question.datasetQuery(),
        );

        expect(rawQuestion.legacyNativeQuery() instanceof NativeQuery).toBe(
          true,
        );
      });
    });
  });

  describe("RESETTING METHODS", () => {
    describe("withoutNameAndId()", () => {
      it("unsets the name and id", () => {
        const newQuestion = orders_raw_question.withoutNameAndId();

        expect(newQuestion.id()).toBeUndefined();
        expect(newQuestion.displayName()).toBeUndefined();
      });

      it("does not change the original", () => {
        expect(orders_raw_question.id()).toBeDefined();
        expect(orders_raw_question.displayName()).toBeDefined();
      });
    });
  });

  describe("VISUALIZATION METHODS", () => {
    describe("display()", () => {
      it("returns the card's visualization type", () => {
        // This forces a table view.
        const tableQuestion = orders_raw_question.setDisplay("table");
        // Not sure I'm a huge fan of magic strings here.
        expect(tableQuestion.display()).toBe("table");
      });
    });

    describe("setDisplay(display)", () => {
      it("sets the card's visualization type", () => {
        // Not sure I'm a huge fan of magic strings here.
        const scalarQuestion = orders_raw_question.setDisplay("scalar");
        expect(scalarQuestion.display()).toBe("scalar");
        expect(orders_raw_question.display()).not.toBe("scalar");
      });
    });

    describe("setDefaultDisplay", () => {
      it("sets display to 'scalar' for order count", () => {
        const question = orders_count_question.setDefaultDisplay();
        expect(question.display()).toBe("scalar");
      });

      it("should not set the display to scalar if table was selected and display is locked", () => {
        const question = orders_count_question
          .setDisplay("table")
          .lockDisplay()
          .maybeResetDisplay(ordersCountData, ["table", "scalar"], undefined);

        expect(question.display()).toBe("table");
      });

      it("should set the display to scalar if a non-scalar was selected and display is locked", () => {
        const question = base_question
          .setDisplay("table")
          .maybeResetDisplay(ordersCountData, ["table", "scalar"], undefined);

        expect(question.display()).toBe("scalar");
      });

      it("should not set the display to scalar if another scalar display was selected and display is locked", () => {
        const question = base_question
          .setDisplay("gauge")
          .maybeResetDisplay(
            ordersCountData,
            ["table", "scalar", "gauge"],
            undefined,
          );

        expect(question.display()).toBe("gauge");
      });

      it("switch to table view if we had a scalar and now have more than 1x1 data", () => {
        const question = base_question
          .setDisplay("scalar")
          .maybeResetDisplay(multipleRowsData, ["table"], undefined);

        expect(question.display()).toBe("table");
      });

      it("should set the display to scalar if funnel was selected", () => {
        const question = orders_count_question
          .setDisplay("funnel")
          .lockDisplay()
          .maybeResetDisplay(ordersCountData, ["table", "scalar"], undefined);

        expect(question.display()).toBe("scalar");
      });
    });

    describe("maybeResetDisplay", () => {
      it("should do nothing when it was locked with sensible display", () => {
        const sensibleDisplays = ["table", "scalar"];
        const previousSensibleDisplays = sensibleDisplays;
        const question = new Question(orders_count_card, metadata)
          .setDisplay("scalar")
          .lockDisplay()
          .maybeResetDisplay(
            ordersCountData,
            sensibleDisplays,
            previousSensibleDisplays,
          );

        expect(question.displayIsLocked()).toBe(true);
        expect(question.display()).toBe("scalar");
      });

      it("should do nothing when it was locked with nonsense display", () => {
        const sensibleDisplays = ["table", "scalar"];
        const previousSensibleDisplays = sensibleDisplays;
        const question = new Question(orders_count_card, metadata)
          .setDisplay("funnel")
          .lockDisplay()
          .maybeResetDisplay(
            ordersCountData,
            sensibleDisplays,
            previousSensibleDisplays,
          );

        expect(question.displayIsLocked()).toBe(true);
        expect(question.display()).toBe("funnel");
      });

      it("should use default display when nonsense display is used and was not locked", () => {
        const sensibleDisplays = ["table", "scalar"];
        const question = base_question
          .setDisplay("funnel")
          .maybeResetDisplay(
            multipleRowsData,
            sensibleDisplays,
            sensibleDisplays,
          );

        expect(question.display()).not.toBe("funnel");
        expect(question.display()).toBe("table");
      });

      it("should unlock and use new sensible display when it was locked with sensible display which has become not sensible", () => {
        const previousSensibleDisplays = ["funnel"];
        const sensibleDisplays = ["table", "scalar"];
        const question = orders_count_question
          .setDisplay("funnel")
          .lockDisplay()
          .maybeResetDisplay(
            ordersCountData,
            sensibleDisplays,
            previousSensibleDisplays,
          );

        expect(question.displayIsLocked()).toBe(false);
        expect(question.display()).not.toBe("funnel");
        expect(sensibleDisplays).toContain(question.display());
      });

      it("should keep any sensible display when display was locked", () => {
        const sensibleDisplays = ["table", "scalar"];
        const question = base_question
          .setDisplay("scalar")
          .lockDisplay()
          .maybeResetDisplay(multipleRowsData, sensibleDisplays, undefined);

        expect(question.display()).not.toBe("table");
        expect(question.display()).toBe("scalar");
      });

      it("should keep any sensible display when display was not locked (metabase#32075)", () => {
        const sensibleDisplays = ["table", "scalar"];
        const question = base_question
          .setDisplay("scalar")
          .maybeResetDisplay(multipleRowsData, sensibleDisplays, undefined);

        expect(question.display()).not.toBe("table");
        expect(question.display()).toBe("scalar");
      });

      it("should switch to scalar display for 1x1 data", () => {
        const sensibleDisplays = ["table", "scalar"];
        const question = orders_count_question
          .setDisplay("table")
          .maybeResetDisplay(ordersCountData, sensibleDisplays, undefined);

        expect(question.display()).not.toBe("table");
        expect(question.display()).toBe("scalar");
      });
    });
  });

  describe("COMPARISON TO OTHER QUESTIONS", () => {
    describe("isDirtyComparedTo(question)", () => {
      it("New questions are automatically dirty", () => {
        const newQuestion = orders_raw_question.withoutNameAndId();
        expect(newQuestion.isDirtyComparedTo(orders_raw_question)).toBe(true);
      });

      it("Changing vis settings makes the question dirty", () => {
        const underlyingDataQuestion = orders_count_question.setSettings({
          "table.pivot": false,
        });
        expect(
          underlyingDataQuestion.isDirtyComparedTo(orders_count_question),
        ).toBe(true);
      });

      it("questions that differ only by randomized idents are considered equal", () => {
        const question1 = Question.create({
          DEPRECATED_RAW_MBQL_databaseId: SAMPLE_DB_ID,
          DEPRECATED_RAW_MBQL_tableId: ORDERS_ID,
        });
        const question2 = Question.create({
          DEPRECATED_RAW_MBQL_databaseId: SAMPLE_DB_ID,
          DEPRECATED_RAW_MBQL_tableId: ORDERS_ID,
        });
        expect(question1.isDirtyComparedTo(question2)).toBe(false);
      });

      it("questions that differ by query only are not considered equal", () => {
        const question1 = Question.create({
          DEPRECATED_RAW_MBQL_databaseId: SAMPLE_DB_ID,
          DEPRECATED_RAW_MBQL_tableId: PRODUCTS_ID,
        });
        const question2 = Question.create({
          DEPRECATED_RAW_MBQL_databaseId: SAMPLE_DB_ID,
          DEPRECATED_RAW_MBQL_tableId: ORDERS_ID,
        });
        expect(question1.isDirtyComparedTo(question2)).toBe(true);
      });
    });
  });

  describe("Question.prototype.getResultMetadata", () => {
    it("should return the `result_metadata` property off the underlying card", () => {
      const columns = [createMockField({ id: 1 }), createMockField({ id: 2 })];
      const question = base_question.setResultsMetadata({ columns });
      expect(question.getResultMetadata()).toEqual(columns);
    });

    it("should default to an array", () => {
      const question = base_question.setResultsMetadata(null);
      expect(question.getResultMetadata()).toEqual([]);
    });
  });

  describe("Question.prototype.setDashboardProps", () => {
    it("should set a `dashboardId` property and a `dashcardId` property on the question's card", () => {
      const questionWithDashboardId = base_question.setDashboardProps({
        dashboardId: 123,
        dashcardId: 456,
      });

      expect(base_question).not.toBe(questionWithDashboardId);
      expect(
        questionWithDashboardId._doNotCallSerializableCard().dashboardId,
      ).toEqual(123);
      expect(
        questionWithDashboardId._doNotCallSerializableCard().dashcardId,
      ).toEqual(456);
    });
  });

  describe("Question.prototype.setParameters", () => {
    it("should set a `parameters` property on the question's card", () => {
      const parameters = [createMockParameter({ type: "category" })];
      const questionWithParameters = base_question.setParameters(parameters);

      expect(base_question).not.toBe(questionWithParameters);
      expect(
        questionWithParameters._doNotCallSerializableCard().parameters,
      ).toEqual(parameters);
    });
  });

  describe("Question.prototype.setParameterValues", () => {
    it("should set a `_parameterValues` property on the question", () => {
      const parameterValues = { foo: "bar" };
      const questionWithParameterValues =
        base_question.setParameterValues(parameterValues);

      expect(base_question).not.toBe(questionWithParameterValues);
      expect(questionWithParameterValues._parameterValues).toEqual(
        parameterValues,
      );
    });
  });

  describe("Question.prototype.parameters", () => {
    it("should return an empty array if no parameters are set on the structured question", () => {
      expect(base_question.parameters()).toEqual([]);
    });

    it("should return the template tags of a native question", () => {
      const nativeQuestionWithTemplateTags = {
        ...native_orders_count_card,
        param_fields: {
          bbb: [createMockField({ id: PRODUCTS.CATEGORY })],
        },
        dataset_query: {
          ...native_orders_count_card.dataset_query,
          native: {
            ...native_orders_count_card.dataset_query.native,
            "template-tags": {
              foo: {
                name: "foo",
                "display-name": "Foo",
                id: "bbb",
                type: "dimension",
                "widget-type": "category",
                dimension: ["field", PRODUCTS.CATEGORY, null],
              },
              bar: {
                name: "bar",
                "display-name": "Bar",
                id: "aaa",
                type: "text",
                value: null,
              },
            },
          },
        },
      };

      const question = new Question(nativeQuestionWithTemplateTags, metadata);
      expect(question.parameters()).toEqual([
        {
          default: undefined,
          fields: [
            expect.objectContaining({
              id: PRODUCTS.CATEGORY,
            }),
          ],
          isMultiSelect: true,
          hasVariableTemplateTagTarget: false,
          id: "bbb",
          name: "Foo",
          slug: "foo",
          target: ["dimension", ["template-tag", "foo"]],
          type: "category",
          value: null,
        },
        {
          default: undefined,
          isMultiSelect: false,
          hasVariableTemplateTagTarget: true,
          id: "aaa",
          name: "Bar",
          slug: "bar",
          target: ["variable", ["template-tag", "bar"]],
          type: "string/=",
          value: null,
        },
      ]);
    });

    it("should return a question's parameters + metadata and the parameter's value if present", () => {
      // slugs differ from names so parameters() deriving a slug would be caught
      const fooParameter = createMockParameter({
        type: "category",
        name: "foo",
        slug: "foo_slug",
        id: "foo_id",
        target: ["dimension", ["field", PRODUCTS.CATEGORY, null]],
      });
      const barParameter = createMockParameter({
        type: "category",
        name: "bar",
        slug: "bar_slug",
        id: "bar_id",
      });
      const question = base_question
        .setParameters([fooParameter, barParameter])
        .setParameterValues({
          foo_id: "abc",
        });

      expect(question.parameters()).toEqual([
        {
          ...fooParameter,
          value: "abc",
          fields: [
            expect.objectContaining({
              id: PRODUCTS.CATEGORY,
            }),
          ],
          hasVariableTemplateTagTarget: false,
        },
        {
          ...barParameter,
          hasVariableTemplateTagTarget: true,
          value: null,
        },
      ]);
    });
  });

  describe("Question.prototype.supportsImplicitActions", () => {
    it("should allow to create implicit actions for a raw model", () => {
      const question = new Question(orders_raw_card, metadata);
      expect(question.supportsImplicitActions()).toBeTruthy();
    });

    it("should not allow to create implicit actions for a model with aggregations", () => {
      const question = new Question(orders_count_card, metadata);
      expect(question.supportsImplicitActions()).toBeFalsy();
    });

    it("should not allow to create implicit actions for a model with filters", () => {
      const question = new Question(orders_filter_card, metadata);
      expect(question.supportsImplicitActions()).toBeFalsy();
    });

    it("should allow to create implicit actions where the underlying table has a primary key but the model does not", () => {
      const orders_question_without_pk = new Question(
        orders_card_without_pk,
        metadata,
      );
      expect(orders_question_without_pk.supportsImplicitActions()).toBeTruthy();
    });

    it("should not allow to create implicit actions where the underlying table has no primary key", () => {
      const question = new Question(orders_raw_card, metadata_without_order_pk);
      expect(question.supportsImplicitActions()).toBeFalsy();
    });

    it("should not allow to create implicit actions where the model has a primary key, but the underlying table does not", () => {
      const question = new Question(
        orders_card_without_pk,
        metadata_without_order_pk,
      );
      expect(question.supportsImplicitActions()).toBeFalsy();
    });

    it("should not allow to create implicit actions for a model with joins", () => {
      const question = new Question(orders_join_card, metadata);
      expect(question.supportsImplicitActions()).toBeFalsy();
    });

    it("should not allow to create implicit actions for a model with expressions", () => {
      const question = new Question(orders_expression_card, metadata);
      expect(question.supportsImplicitActions()).toBeFalsy();
    });

    it("should not allow to create implicit actions for a model with multiple stages", () => {
      const question = new Question(orders_multi_stage_card, metadata);
      expect(question.supportsImplicitActions()).toBeFalsy();
    });

    it("should allow to create implicit actions for a native model", () => {
      const question = new Question(native_orders_count_card, metadata);
      expect(question.supportsImplicitActions()).toBeFalsy();
    });
  });

  describe("Question.generateQueryDescription", () => {
    it("should work with multiple aggregations", () => {
      const question = base_question.setDatasetQuery({
        type: "query",
        database: SAMPLE_DB_ID,
        query: {
          "source-table": ORDERS_ID,
          aggregation: [["count"], ["sum", ["field", ORDERS.TOTAL, null]]],
        },
      });
      expect(question.generateQueryDescription()).toEqual(
        "Orders, Count and Sum of Total",
      );
    });

    it("should work with named aggregations", () => {
      const question = base_question.setDatasetQuery({
        type: "query",
        database: SAMPLE_DB_ID,
        query: {
          "source-table": ORDERS_ID,
          aggregation: [
            [
              "aggregation-options",
              ["sum", ["field", 1, null]],
              // name differs from display-name to pin which key the description uses
              { name: "revenue_sum", "display-name": "Revenue" },
            ],
          ],
        },
      });
      expect(question.generateQueryDescription()).toEqual("Orders, Revenue");
    });
  });
});