Skip to content

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

MBQL lib test helpers (#68168)

Romeo Van Snick1284c201b52f
diff --git a/frontend/src/metabase-lib/comparison.unit.spec.ts b/frontend/src/metabase-lib/comparison.unit.spec.ts
index dfb846c9c00..b4f67f998e7 100644
--- a/frontend/src/metabase-lib/comparison.unit.spec.ts
+++ b/frontend/src/metabase-lib/comparison.unit.spec.ts
@@ -1,22 +1,31 @@
import * as Lib from "metabase-lib";
+import { ORDERS_ID } from "metabase-types/api/mocks/presets";
-import { createQueryWithClauses } from "./test-helpers";
+import {
+ SAMPLE_DATABASE,
+ SAMPLE_PROVIDER,
+ createTestQuery,
+} from "./test-helpers";
describe("findColumnIndexesFromLegacyRefs", () => {
const stageIndex = -1;
it("should match columns that differ only by temporal buckets", () => {
- const query = createQueryWithClauses({
- breakouts: [
+ const query = createTestQuery(SAMPLE_PROVIDER, {
+ databaseId: SAMPLE_DATABASE.id,
+ stages: [
{
- tableName: "ORDERS",
- columnName: "CREATED_AT",
- temporalBucketName: "Year",
- },
- {
- tableName: "ORDERS",
- columnName: "CREATED_AT",
- temporalBucketName: "Month",
+ source: { type: "table", id: ORDERS_ID },
+ breakouts: [
+ {
+ name: "CREATED_AT",
+ unit: "year",
+ },
+ {
+ name: "CREATED_AT",
+ unit: "month",
+ },
+ ],
},
],
});
@@ -31,17 +40,21 @@ describe("findColumnIndexesFromLegacyRefs", () => {
});
it("should match columns that differ only by binning", () => {
- const query = createQueryWithClauses({
- breakouts: [
- {
- tableName: "ORDERS",
- columnName: "TOTAL",
- binningStrategyName: "10 bins",
- },
+ const query = createTestQuery(SAMPLE_PROVIDER, {
+ databaseId: SAMPLE_DATABASE.id,
+ stages: [
{
- tableName: "ORDERS",
- columnName: "TOTAL",
- binningStrategyName: "50 bins",
+ source: { type: "table", id: ORDERS_ID },
+ breakouts: [
+ {
+ name: "TOTAL",
+ binningCount: 10,
+ },
+ {
+ name: "TOTAL",
+ binningCount: 50,
+ },
+ ],
},
],
});
diff --git a/frontend/src/metabase-lib/test-helpers.ts b/frontend/src/metabase-lib/test-helpers.ts
index 6427af28133..6377892d1d2 100644
--- a/frontend/src/metabase-lib/test-helpers.ts
+++ b/frontend/src/metabase-lib/test-helpers.ts
@@ -5,9 +5,11 @@ import { checkNotNull } from "metabase/lib/types";
import * as Lib from "metabase-lib";
import type Metadata from "metabase-lib/v1/metadata/Metadata";
import type {
+ CardId,
DatabaseId,
DatasetColumn,
DatasetQuery,
+ JoinStrategy,
RowValue,
TableId,
} from "metabase-types/api";
@@ -20,14 +22,19 @@ const SAMPLE_DATABASE = createSampleDatabase();
const SAMPLE_METADATA = createMockMetadata({ databases: [SAMPLE_DATABASE] });
-export { SAMPLE_DATABASE, SAMPLE_METADATA };
+const SAMPLE_PROVIDER = createMetadataProvider({
+ databaseId: SAMPLE_DATABASE.id,
+ metadata: SAMPLE_METADATA,
+});
+
+export { SAMPLE_DATABASE, SAMPLE_METADATA, SAMPLE_PROVIDER };
type MetadataProviderOpts = {
databaseId?: DatabaseId;
metadata?: Metadata;
};
-function createMetadataProvider({
+export function createMetadataProvider({
databaseId = SAMPLE_DATABASE.id,
metadata = SAMPLE_METADATA,
}: MetadataProviderOpts = {}) {
@@ -46,6 +53,9 @@ type QueryOpts = MetadataProviderOpts & {
query?: DatasetQuery;
};
+/**
+ * @deprecated: Use createTestQuery, createTestJsQuery, createTestNativeQuery or createTestNativeJsQuery instead.
+ */
export function createQuery({
databaseId = SAMPLE_DATABASE.id,
metadata = SAMPLE_METADATA,
@@ -200,6 +210,9 @@ interface QueryWithClausesOpts {
orderBys?: OrderByClauseOpts[];
}
+/**
+ * @deprecated: Use createTestQuery or createTestJsQuery instead.
+ */
export function createQueryWithClauses({
query = createQuery(),
expressions = [],
@@ -408,3 +421,525 @@ export function createLegendItemClickObject(
) {
return { dimensions: [dimension] };
}
+
+type CreateTestQueryOpts = {
+ databaseId: DatabaseId;
+ stages: [TestQueryStageWithSource, ...TestQueryStage[]];
+};
+
+type TestQueryStage = {
+ limit?: Lib.Limit;
+ fields?: TestQueryColumnExpression[] | "all";
+ joins?: TestQueryJoin[];
+ filters?: TestQueryFilter[];
+ aggregations?: TestQueryAggregation[];
+ expressions?: TestQueryNamedExpression[];
+ breakouts?: TestQueryBreakout[];
+ orderBy?: TestQueryOrderBy[];
+};
+
+type TestQueryStageWithSource = TestQueryStage & {
+ source: TestQuerySource;
+};
+
+type TestQueryTableSource = { type: "table"; id: TableId };
+type TestQueryCardSource = { type: "card"; id: CardId };
+type TestQuerySource = TestQueryTableSource | TestQueryCardSource;
+
+type TestQueryJoin = {
+ source: TestQuerySource;
+ strategy: JoinStrategy;
+
+ // If not set we will used the suggested join conditions
+ conditions?: TestQueryJoinCondition[];
+};
+
+type TestQueryJoinCondition = {
+ operator: Lib.JoinConditionOperator;
+ left: TestQueryExpression;
+ right: TestQueryExpression;
+};
+
+type TestQueryNamedExpression = {
+ name: string;
+ value: TestQueryExpression;
+};
+
+type TestQueryFilter = TestQueryExpression;
+
+type TestQueryAggregation = TestQueryExpression | TestQueryNamedExpression;
+
+type TestQueryExpression =
+ | TestQueryLiteralExpression
+ | TestQueryColumnExpression
+ | TestQueryOperatorExpression;
+
+type TestQueryLiteralExpression = {
+ type: "literal";
+ value: number | bigint | string | boolean;
+};
+
+type TestQueryColumnExpression = {
+ type: "column";
+ groupName?: string;
+ name: string;
+};
+
+type TestQueryOperatorExpression = {
+ type: "operator";
+ operator: Lib.ExpressionOperator;
+ args: TestQueryExpression[];
+};
+
+type TestQueryBreakout = {
+ name: string;
+ groupName?: string;
+ unit?: string;
+ binningCount?: number | "auto";
+};
+
+type TestQueryOrderBy = {
+ name: string;
+ groupName?: string;
+ direction: Lib.OrderByDirection;
+};
+
+export function createTestQuery(
+ metadataProvider: Lib.MetadataProvider,
+ { stages }: CreateTestQueryOpts,
+): Lib.Query {
+ if (stages.length === 0) {
+ throw new Error("query must have at least one stage");
+ }
+
+ if (!stages[0].source) {
+ throw new Error("query must have a source in the first stage");
+ }
+
+ const firstSource = findSource(metadataProvider, stages[0].source);
+
+ const initialQuery = Lib.queryFromTableOrCardMetadata(
+ metadataProvider,
+ firstSource,
+ );
+
+ return stages.reduce(
+ (query: Lib.Query, stage, stageIndex) =>
+ appendTestQueryStage(metadataProvider, stage, query, stageIndex),
+ initialQuery,
+ );
+}
+
+export function createTestJsQuery(
+ metadataProvider: Lib.MetadataProvider,
+ opts: CreateTestQueryOpts,
+) {
+ return Lib.toJsQuery(createTestQuery(metadataProvider, opts));
+}
+
+function appendTestQueryStage(
+ metadataProvider: Lib.MetadataProvider,
+ stage: TestQueryStage,
+ query: Lib.Query,
+ stageIndex: number,
+): Lib.Query {
+ const {
+ limit,
+ joins = [],
+ expressions = [],
+ filters = [],
+ aggregations = [],
+ breakouts = [],
+ orderBy = [],
+ } = stage;
+
+ const queryWithStage = Lib.appendStage(query);
+
+ const queryWithLimit =
+ limit == null
+ ? queryWithStage
+ : Lib.limit(queryWithStage, stageIndex, limit);
+
+ // Add joins to stage
+ const queryWithJoins = joins.reduce((query, join) => {
+ const joinClause = createTestJoinClause(
+ metadataProvider,
+ query,
+ stageIndex,
+ join,
+ );
+ return Lib.join(query, stageIndex, joinClause);
+ }, queryWithLimit);
+
+ // Add expressions
+ const queryWithExpressions = expressions.reduce((query, expression) => {
+ const expressionClause = expressionToExpressionClause(
+ query,
+ stageIndex,
+ Lib.visibleColumns(query, stageIndex),
+ expression.value,
+ );
+ return Lib.expression(query, stageIndex, expression.name, expressionClause);
+ }, queryWithJoins);
+
+ // Limit query fields
+ const visibleColumns = Lib.visibleColumns(queryWithJoins, stageIndex);
+ const queryWithFields =
+ stage.fields == null || stage.fields === "all"
+ ? // If no fields are specified, we use all the visible fields
+ queryWithExpressions
+ : // If fields are specified, we use only those fields
+ Lib.withFields(
+ queryWithExpressions,
+ stageIndex,
+ stage.fields.map((field) =>
+ findColumn(queryWithJoins, stageIndex, visibleColumns, field),
+ ),
+ );
+
+ // Add filters
+ const queryWithFilters = filters.reduce((query, filter) => {
+ const filterClause = createTestFilterClause(
+ metadataProvider,
+ query,
+ stageIndex,
+ filter,
+ );
+ return Lib.filter(query, stageIndex, filterClause);
+ }, queryWithFields);
+
+ // Add aggregations
+ const queryWithAggregations = aggregations.reduce((query, aggregation) => {
+ const aggregationClause = createTestAggregationClause(
+ metadataProvider,
+ query,
+ stageIndex,
+ aggregation,
+ );
+ return Lib.aggregate(query, stageIndex, aggregationClause);
+ }, queryWithFilters);
+
+ // Add breakouts
+ const queryWithBreakouts = breakouts.reduce((query, breakout) => {
+ const clause = createTestBreakoutClause(
+ metadataProvider,
+ query,
+ stageIndex,
+ breakout,
+ );
+ return Lib.breakout(query, stageIndex, clause);
+ }, queryWithAggregations);
+
+ const queryWithOrderBys = orderBy.reduce((query, orderBy) => {
+ const columns = Lib.orderableColumns(query, stageIndex);
+ const column = findColumn(query, stageIndex, columns, {
+ type: "column",
+ name: orderBy.name,
+ groupName: orderBy.groupName,
+ });
+ return Lib.orderBy(query, stageIndex, column, orderBy.direction);
+ }, queryWithBreakouts);
+
+ return queryWithOrderBys;
+}
+
+function findSource(
+ provider: Lib.MetadataProvider,
+ source: TestQuerySource,
+): Lib.TableMetadata | Lib.CardMetadata {
+ const metadata = Lib.tableOrCardMetadata(provider, source.id);
+
+ if (!metadata) {
+ throw new Error(`Could not find source metadata for source: ${source.id}`);
+ }
+
+ return metadata;
+}
+
+function getGroupColumns(
+ query: Lib.Query,
+ stageIndex: number,
+ columns: Lib.ColumnMetadata[],
+ column: TestQueryColumnExpression,
+) {
+ if (column.groupName) {
+ const groups = Lib.groupColumns(columns);
+ const group = groups.find((group) => {
+ const info = Lib.displayInfo(query, stageIndex, group);
+ return info.displayName === column.groupName;
+ });
+ if (!group) {
+ const groupNames = groups.map(
+ (group) => Lib.displayInfo(query, 0, group).displayName,
+ );
+ throw new Error(
+ `Could not find group named ${column.groupName}, available names are: ${groupNames.join(", ")}`,
+ );
+ }
+ return Lib.getColumnsFromColumnGroup(group);
+ }
+ return columns;
+}
+
+function findColumn(
+ query: Lib.Query,
+ stageIndex: number,
+ columns: Lib.ColumnMetadata[],
+ column: TestQueryColumnExpression,
+) {
+ const columnsFromGroup = getGroupColumns(query, stageIndex, columns, column);
+ const candidates = columnsFromGroup.filter((candidate) => {
+ const displayInfo = Lib.displayInfo(query, stageIndex, candidate);
+ return column.name === displayInfo.name;
+ });
+
+ if (candidates.length === 0) {
+ throw new Error(`Could not find column named "${column.name}"`);
+ } else if (candidates.length > 1 && column.groupName == null) {
+ // If there is only one candidate that is not from an (implicit) join, return that one
+ const filteredCandidates = candidates.filter((candidate) => {
+ const displayInfo = Lib.displayInfo(query, stageIndex, candidate);
+ return !displayInfo.isFromJoin && !displayInfo.isImplicitlyJoinable;
+ });
+
+ if (filteredCandidates.length === 1) {
+ return filteredCandidates[0];
+ }
+
+ throw new Error(
+ `More than one column named "${column.name}", please disambiguate using groupName`,
+ );
+ } else {
+ // Just one candidate found, or they are all from the same table,
+ // so they represent the same column. Return the first candidate.
+ return candidates[0];
+ }
+}
+
+function createTestJoinClause(
+ metadataProvider: Lib.MetadataProvider,
+ query: Lib.Query,
+ stageIndex: number,
+ join: TestQueryJoin,
+) {
+ const targetMetadata = findSource(metadataProvider, join.source);
+
+ // Pick join strategy
+ const joinStrategy = findJoinStrategy(query, stageIndex, join.strategy);
+
+ // Build join conditions
+ const conditions =
+ join.conditions == null
+ ? // If no conditions are specified, use the suggested conditions
+ Lib.suggestedJoinConditions(query, stageIndex, targetMetadata)
+ : // If conditions are specified, use them
+ join.conditions.map((condition) => {
+ const lhs = expressionToJoinConditionExpression(
+ query,
+ stageIndex,
+ Lib.joinConditionLHSColumns(query, stageIndex),
+ condition.left,
+ );
+
+ const rhs = expressionToJoinConditionExpression(
+ query,
+ stageIndex,
+ Lib.joinConditionRHSColumns(query, stageIndex, targetMetadata, lhs),
+ condition.right,
+ );
+
+ return Lib.joinConditionClause(condition.operator, lhs, rhs);
+ });
+
+ return Lib.joinClause(targetMetadata, conditions, joinStrategy);
+}
+
+function findJoinStrategy(
+ query: Lib.Query,
+ stageIndex: number,
+ strategyName: JoinStrategy,
+) {
+ const availableJoinStrategies = Lib.availableJoinStrategies(
+ query,
+ stageIndex,
+ );
+ const joinStrategy = availableJoinStrategies.find(
+ (strategy) =>
+ Lib.displayInfo(query, stageIndex, strategy).shortName === strategyName,
+ );
+ if (!joinStrategy) {
+ throw new Error(`Could not find join strategy "${strategyName}"`);
+ }
+ return joinStrategy;
+}
+
+function expressionToExpressionParts(
+ query: Lib.Query,
+ stageIndex: number,
+ availableColumns: Lib.ColumnMetadata[],
+ expression: TestQueryExpression,
+): Lib.ExpressionArg | Lib.ExpressionParts {
+ switch (expression.type) {
+ case "literal":
+ return expression.value;
+ case "column":
+ return findColumn(query, stageIndex, availableColumns, expression);
+ case "operator":
+ return {
+ operator: expression.operator,
+ options: {},
+ args: expression.args.map((arg) =>
+ expressionToExpressionParts(query, stageIndex, availableColumns, arg),
+ ),
+ };
+ }
+}
+
+function expressionToExpressionClause(
+ query: Lib.Query,
+ stageIndex: number,
+ availableColumns: Lib.ColumnMetadata[],
+ expression: TestQueryExpression,
+): Lib.ExpressionClause {
+ const expressionParts = expressionToExpressionParts(
+ query,
+ stageIndex,
+ availableColumns,
+ expression,
+ );
+ return Lib.expressionClause(expressionParts);
+}
+
+function expressionToJoinConditionExpression(
+ query: Lib.Query,
+ stageIndex: number,
+ joinableColumns: Lib.ColumnMetadata[],
+ expression: TestQueryExpression,
+) {
+ switch (expression.type) {
+ case "column":
+ return findColumn(query, stageIndex, joinableColumns, expression);
+ case "operator":
+ case "literal": {
+ return expressionToExpressionClause(
+ query,
+ stageIndex,
+ joinableColumns,
+ expression,
+ );
+ }
+ }
+}
+
+function createTestFilterClause(
+ _metadataProvider: Lib.MetadataProvider,
+ query: Lib.Query,
+ stageIndex: number,
+ filter: TestQueryFilter,
+): Lib.ExpressionClause {
+ return expressionToExpressionClause(
+ query,
+ stageIndex,
+ Lib.filterableColumns(query, stageIndex),
+ filter,
+ );
+}
+
+function createTestAggregationClause(
+ metadataProvider: Lib.MetadataProvider,
+ query: Lib.Query,
+ stageIndex: number,
+ aggregation: TestQueryAggregation,
+): Lib.ExpressionClause {
+ if ("name" in aggregation && "value" in aggregation) {
+ const clause = createTestAggregationClause(
+ metadataProvider,
+ query,
+ stageIndex,
+ aggregation.value,
+ );
+ return Lib.withExpressionName(clause, aggregation.name);
+ }
+
+ const clause = expressionToExpressionClause(
+ query,
+ stageIndex,
+ Lib.aggregableColumns(query, stageIndex),
+ aggregation,
+ );
+ return clause;
+}
+
+function createTestBreakoutClause(
+ _metadataProvider: Lib.MetadataProvider,
+ query: Lib.Query,
+ stageIndex: number,
+ breakout: TestQueryBreakout,
+): Lib.ColumnMetadata {
+ const columns = Lib.breakoutableColumns(query, stageIndex);
+ const column = findColumn(query, stageIndex, columns, {
+ type: "column",
+ name: breakout.name,
+ groupName: breakout.groupName,
+ });
+
+ if (breakout.unit) {
+ const buckets = Lib.availableTemporalBuckets(query, stageIndex, column);
+ const bucket = buckets.find((candidate) => {
+ const info = Lib.displayInfo(query, stageIndex, candidate);
+ return info.shortName === breakout.unit;
+ });
+
+ if (!bucket) {
+ throw new Error(`Could not find temporal bucket ${breakout.unit}`);
+ }
+
+ return Lib.withTemporalBucket(column, bucket);
+ }
+
+ if (breakout.binningCount) {
+ const strategies = Lib.availableBinningStrategies(
+ query,
+ stageIndex,
+ column,
+ );
+ const strategy = strategies.find((candidate) => {
+ const info = Lib.displayInfo(query, stageIndex, candidate);
+ return (
+ (breakout.binningCount === "auto" && info.displayName === "Auto bin") ||
+ info.displayName === `${breakout.binningCount} bins`
+ );
+ });
+
+ if (!strategy) {
+ throw new Error(
+ `Could not find binning strategy: ${breakout.binningCount}`,
+ );
+ }
+
+ return Lib.withBinning(column, strategy);
+ }
+
+ return column;
+}
+
+export function createTestNativeQuery(
+ metadataProvider: Lib.MetadataProvider,
+ databaseId: DatabaseId,
+ query: string,
+): Lib.Query {
+ return Lib.nativeQuery(databaseId, metadataProvider, query);
+}
+
+export function createTestNativeJsQuery(
+ metadataProvider: Lib.MetadataProvider,
+ databaseId: DatabaseId,
+ query: string,
+) {
+ const nativeQuery = createTestNativeQuery(
+ metadataProvider,
+ databaseId,
+ query,
+ );
+ return Lib.toJsQuery(nativeQuery);
+}
diff --git a/frontend/src/metabase-lib/test-helpers.unit.spec.ts b/frontend/src/metabase-lib/test-helpers.unit.spec.ts
new file mode 100644
index 00000000000..3ed2bb9b874
--- /dev/null
+++ b/frontend/src/metabase-lib/test-helpers.unit.spec.ts
@@ -0,0 +1,182 @@
+import * as Lib from "metabase-lib";
+import {
+ SAMPLE_DATABASE,
+ SAMPLE_METADATA,
+ createTestQuery,
+} from "metabase-lib/test-helpers";
+import { ORDERS_ID, PEOPLE_ID } from "metabase-types/api/mocks/presets";
+
+describe("createTestQuery", () => {
+ it("should create a query with stages", () => {
+ const provider = Lib.metadataProvider(SAMPLE_DATABASE.id, SAMPLE_METADATA);
+ const query = createTestQuery(provider, {
+ databaseId: SAMPLE_DATABASE.id,
+ stages: [
+ {
+ source: {
+ type: "table",
+ id: ORDERS_ID,
+ },
+ fields: [
+ {
+ type: "column",
+ groupName: "People",
+ name: "ID",
+ },
+ {
+ type: "column",
+ groupName: "Orders",
+ name: "ID",
+ },
+ ],
+ joins: [
+ {
+ source: {
+ type: "table",
+ id: PEOPLE_ID,
+ },
+ strategy: "inner-join",
+ conditions: [
+ {
+ operator: "=",
+ left: {
+ type: "column",
+ name: "USER_ID",
+ },
+ right: {
+ type: "operator",
+ operator: "+",
+ args: [
+ {
+ type: "column",
+ name: "ID",
+ },
+ {
+ type: "literal",
+ value: 1,
+ },
+ ],
+ },
+ },
+ ],
+ },
+ ],
+ filters: [
+ {
+ type: "operator",
+ operator: ">=",
+ args: [
+ {
+ type: "column",
+ name: "TOTAL",
+ },
+ {
+ type: "literal",
+ value: 10,
+ },
+ ],
+ },
+ ],
+ aggregations: [
+ {
+ name: "Foo",
+ value: {
+ type: "operator",
+ operator: "avg",
+ args: [
+ {
+ type: "column",
+ name: "TOTAL",
+ },
+ ],
+ },
+ },
+ ],
+ breakouts: [
+ {
+ name: "CREATED_AT",
+ unit: "month",
+ },
+ ],
+ expressions: [
+ {
+ name: "Bar",
+ value: {
+ type: "operator",
+ operator: "+",
+ args: [
+ { type: "column", name: "SUBTOTAL" },
+ { type: "literal", value: 50 },
+ ],
+ },
+ },
+ ],
+ orderBy: [
+ {
+ name: "CREATED_AT",
+ direction: "desc",
+ },
+ ],
+ limit: 101,
+ },
+ {
+ expressions: [
+ {
+ name: "FooPlusOne",
+ value: {
+ type: "operator",
+ operator: "+",
+ args: [
+ { type: "column", name: "Foo" },
+ { type: "literal", value: 1 },
+ ],
+ },
+ },
+ ],
+ },
+ ],
+ });
+
+ const customExpressions = Lib.expressions(query, 0).map(
+ (expression) => Lib.displayInfo(query, 0, expression).displayName,
+ );
+ expect(customExpressions).toEqual(["Bar"]);
+
+ const fields = Lib.fields(query, 0).map(
+ (field) => Lib.displayInfo(query, -1, field).displayName,
+ );
+ expect(fields).toEqual(["People → ID", "ID", "Bar"]);
+
+ const joins = Lib.joins(query, 0).map((join) => {
+ const joinConditions = Lib.joinConditions(join);
+ return joinConditions.map(
+ (condition) => Lib.displayInfo(query, 0, condition).longDisplayName,
+ );
+ });
+ expect(joins).toEqual([["User ID is ID + 1"]]);
+
+ const filters = Lib.filters(query, 0).map(
+ (filter) => Lib.displayInfo(query, 0, filter).displayName,
+ );
+ expect(filters).toEqual(["Total is greater than or equal to 10"]);
+
+ const aggregations = Lib.aggregations(query, 0).map(
+ (aggregation) => Lib.displayInfo(query, 0, aggregation).displayName,
+ );
+ expect(aggregations).toEqual(["Foo"]);
+
+ const orderBys = Lib.orderBys(query, 0).map((orderBy) => {
+ const info = Lib.displayInfo(query, 0, orderBy);
+ return {
+ name: info.displayName,
+ direction: info.direction,
+ };
+ });
+ expect(orderBys).toEqual([
+ { name: "Created At: Month", direction: "desc" },
+ ]);
+
+ const limit = Lib.currentLimit(query, 0);
+ expect(limit).toEqual(101);
+ });
+});
diff --git a/frontend/src/metabase-lib/viz/display.unit.spec.ts b/frontend/src/metabase-lib/viz/display.unit.spec.ts
index a6585e9879f..53f5baa7942 100644
--- a/frontend/src/metabase-lib/viz/display.unit.spec.ts
+++ b/frontend/src/metabase-lib/viz/display.unit.spec.ts
@@ -2,11 +2,20 @@ import { createMockMetadata } from "__support__/metadata";
import type { Field, Table } from "metabase-types/api";
import { createMockField, createMockTable } from "metabase-types/api/mocks";
import {
+ ORDERS_ID,
SAMPLE_DB_ID,
+ createOrdersTable,
+ createPeopleTable,
+ createProductsTable,
+ createReviewsTable,
createSampleDatabase,
} from "metabase-types/api/mocks/presets";
-import { createQuery, createQueryWithClauses } from "../test-helpers";
+import {
+ createMetadataProvider,
+ createTestNativeQuery,
+ createTestQuery,
+} from "../test-helpers";
import { defaultDisplay } from "./display";
@@ -38,45 +47,90 @@ const createAccountsCountryField = (opts?: Partial<Field>): Field =>
});
const SAMPLE_DATABASE = createSampleDatabase({
- tables: [createAccountsTable()],
+ tables: [
+ createProductsTable(),
+ createReviewsTable(),
+ createOrdersTable(),
+ createPeopleTable(),
+ createAccountsTable(),
+ ],
+});
+
+const SAMPLE_METADATA = createMockMetadata({
+ databases: [SAMPLE_DATABASE],
});
-const SAMPLE_METADATA = createMockMetadata({ databases: [SAMPLE_DATABASE] });
+const SAMPLE_PROVIDER = createMetadataProvider({
+ databaseId: SAMPLE_DATABASE.id,
+ metadata: SAMPLE_METADATA,
+});
describe("defaultDisplay", () => {
it("returns 'table' display for native queries", () => {
- const query = createQuery({
- metadata: SAMPLE_METADATA,
- query: {
- database: SAMPLE_DATABASE.id,
- type: "native",
- native: {
- query: "SELECT * FROM ACCOUNTS",
- },
- },
- });
-
+ const query = createTestNativeQuery(
+ SAMPLE_PROVIDER,
+ SAMPLE_DATABASE.id,
+ "SELECT * FROM ACCOUNTS",
+ );
expect(defaultDisplay(query)).toEqual({ display: "table" });
});
it("returns 'table' display for queries with no aggregations and no breakouts", () => {
- const query = createQuery();
+ const query = createTestQuery(SAMPLE_PROVIDER, {
+ databaseId: SAMPLE_DATABASE.id,
+ stages: [
+ {
+ source: {
+ type: "table",
+ id: ORDERS_ID,
+ },
+ },
+ ],
+ });
expect(defaultDisplay(query)).toEqual({ display: "table" });
});
it("returns 'scalar' display for queries with 1 aggregation and no breakouts", () => {
- const query = createQueryWithClauses({
- aggregations: [{ operatorName: "count" }],
+ const query = createTestQuery(SAMPLE_PROVIDER, {
+ databaseId: SAMPLE_DATABASE.id,
+ stages: [
+ {
+ source: {
+ type: "table",
+ id: ORDERS_ID,
+ },
+ aggregations: [
+ {
+ name: "Count",
+ value: { type: "operator", operator: "count", args: [] },
+ },
+ ],
+ },
+ ],
});
expect(defaultDisplay(query)).toEqual({ display: "scalar" });
});
it("returns 'map' display for queries with 1 aggregation and 1 breakout by state", () => {
- const query = createQueryWithClauses({
- aggregations: [{ operatorName: "count" }],
- breakouts: [{ columnName: "STATE", tableName: "PEOPLE" }],
+ const query = createTestQuery(SAMPLE_PROVIDER, {
+ databaseId: SAMPLE_DATABASE.id,
+ stages: [
+ {
+ source: {
+ type: "table",
+ id: ORDERS_ID,
+ },
+ aggregations: [
+ {
+ name: "Count",
+ value: { type: "operator", operator: "count", args: [] },
+ },
+ ],
+ breakouts: [{ name: "STATE" }],
+ },
+ ],
});
expect(defaultDisplay(query)).toEqual({
@@ -89,19 +143,27 @@ describe("defaultDisplay", () => {
});
it("returns 'map' display for queries with 1 aggregation and 1 breakout by country", () => {
- const query = createQueryWithClauses({
- query: createQuery({
- metadata: SAMPLE_METADATA,
- query: {
- database: SAMPLE_DATABASE.id,
- type: "query",
- query: {
- "source-table": ACCOUNTS_ID,
+ const query = createTestQuery(SAMPLE_PROVIDER, {
+ databaseId: SAMPLE_DATABASE.id,
+ stages: [
+ {
+ source: {
+ type: "table",
+ id: ACCOUNTS_ID,
},
+ aggregations: [
+ {
+ name: "Count",
+ value: { type: "operator", operator: "count", args: [] },
+ },
+ ],
+ breakouts: [
+ {
+ name: "COUNTRY",
+ },
+ ],
},
- }),
- aggregations: [{ operatorName: "count" }],
- breakouts: [{ columnName: "COUNTRY", tableName: "ACCOUNTS" }],
+ ],
});
expect(defaultDisplay(query)).toEqual({
@@ -114,13 +176,27 @@ describe("defaultDisplay", () => {
});
it("returns 'bar' display for queries with aggregations and 1 breakout by date with temporal bucketing", () => {
- const query = createQueryWithClauses({
- aggregations: [{ operatorName: "count" }],
- breakouts: [
+ const query = createTestQuery(SAMPLE_PROVIDER, {
+ databaseId: SAMPLE_DATABASE.id,
+ stages: [
{
- columnName: "CREATED_AT",
- tableName: "ORDERS",
- temporalBucketName: "Day of month",
+ source: {
+ type: "table",
+ id: ORDERS_ID,
+ },
+ aggregations: [
+ {
+ name: "Count",
+ value: { type: "operator", operator: "count", args: [] },
+ },
+ ],
+ breakouts: [
+ {
+ name: "CREATED_AT",
+ groupName: "Orders",
+ unit: "day-of-month",
+ },
+ ],
},
],
});
@@ -129,53 +205,134 @@ describe("defaultDisplay", () => {
});
it("returns 'line' display for queries with aggregations and 1 breakout by date without temporal bucketing", () => {
- const query = createQueryWithClauses({
- aggregations: [{ operatorName: "count" }],
- breakouts: [{ columnName: "CREATED_AT", tableName: "ORDERS" }],
+ const query = createTestQuery(SAMPLE_PROVIDER, {
+ databaseId: SAMPLE_DATABASE.id,
+ stages: [
+ {
+ source: {
+ type: "table",
+ id: ORDERS_ID,
+ },
+ aggregations: [
+ {
+ name: "Count",
+ value: { type: "operator", operator: "count", args: [] },
+ },
+ ],
+ breakouts: [
+ {
+ name: "CREATED_AT",
+ groupName: "Orders",
+ },
+ ],
+ },
+ ],
});
expect(defaultDisplay(query)).toEqual({ display: "line" });
});
it("returns 'bar' display for queries with aggregations and 1 breakout with binning", () => {
- const query = createQueryWithClauses({
- aggregations: [{ operatorName: "count" }],
- breakouts: [
+ const query = createTestQuery(SAMPLE_PROVIDER, {
+ databaseId: SAMPLE_DATABASE.id,
+ stages: [
{
- columnName: "TOTAL",
- tableName: "ORDERS",
- binningStrategyName: "10 bins",
+ source: {
+ type: "table",
+ id: ORDERS_ID,
+ },
+ aggregations: [
+ {
+ name: "Count",
+ value: { type: "operator", operator: "count", args: [] },
+ },
+ ],
+ breakouts: [
+ {
+ name: "TOTAL",
+ groupName: "Orders",
+ binningCount: 10,
+ },
+ ],
},
],
});
-
expect(defaultDisplay(query)).toEqual({ display: "bar" });
});
it("returns 'table' display for queries with aggregations and 1 breakout without binning", () => {
- const query = createQueryWithClauses({
- aggregations: [{ operatorName: "count" }],
- breakouts: [{ columnName: "TOTAL", tableName: "ORDERS" }],
+ const query = createTestQuery(SAMPLE_PROVIDER, {
+ databaseId: SAMPLE_DATABASE.id,
+ stages: [
+ {
+ source: {
+ type: "table",
+ id: ORDERS_ID,
+ },
+ aggregations: [
+ {
+ name: "Count",
+ value: { type: "operator", operator: "count", args: [] },
+ },
+ ],
+ breakouts: [
+ {
+ name: "TOTAL",
+ groupName: "Orders",
+ },
+ ],
+ },
+ ],
});
expect(defaultDisplay(query)).toEqual({ display: "table" });
});
it("returns 'bar' display for queries with aggregations and 1 breakout by category", () => {
- const query = createQueryWithClauses({
- aggregations: [{ operatorName: "count" }],
- breakouts: [{ columnName: "CATEGORY", tableName: "PRODUCTS" }],
+ const query = createTestQuery(SAMPLE_PROVIDER, {
+ databaseId: SAMPLE_DATABASE.id,
+ stages: [
+ {
+ source: {
+ type: "table",
+ id: ORDERS_ID,
+ },
+ aggregations: [
+ {
+ name: "Count",
+ value: { type: "operator", operator: "count", args: [] },
+ },
+ ],
+ breakouts: [
+ {
+ name: "CATEGORY",
+ groupName: "Product",
+ },
+ ],
+ },
+ ],
});
expect(defaultDisplay(query)).toEqual({ display: "bar" });
});
it("returns 'line' display for queries with 1 aggregation and 2 breakouts, at least 1 of which is by date", () => {
- const query = createQueryWithClauses({
- aggregations: [{ operatorName: "count" }],
- breakouts: [
- { columnName: "CREATED_AT", tableName: "ORDERS" },
- { columnName: "TOTAL", tableName: "ORDERS" },
+ const query = createTestQuery(SAMPLE_PROVIDER, {
+ databaseId: SAMPLE_DATABASE.id,
+ stages: [
+ {
+ source: {
+ type: "table",
+ id: ORDERS_ID,
+ },
+ aggregations: [
+ {
+ name: "Count",
+ value: { type: "operator", operator: "count", args: [] },
+ },
+ ],
+ breakouts: [{ name: "CREATED_AT" }, { name: "TOTAL" }],
+ },
],
});
@@ -183,18 +340,30 @@ describe("defaultDisplay", () => {
});
it("returns 'map' display with 'grid' type for queries with 1 aggregation and 2 binned breakouts by coordinates", () => {
- const query = createQueryWithClauses({
- aggregations: [{ operatorName: "count" }],
- breakouts: [
+ const query = createTestQuery(SAMPLE_PROVIDER, {
+ databaseId: SAMPLE_DATABASE.id,
+ stages: [
{
- columnName: "LATITUDE",
- tableName: "PEOPLE",
- binningStrategyName: "Auto bin",
- },
- {
- columnName: "LONGITUDE",
- tableName: "PEOPLE",
- binningStrategyName: "Auto bin",
+ source: {
+ type: "table",
+ id: ORDERS_ID,
+ },
+ aggregations: [
+ {
+ name: "Count",
+ value: { type: "operator", operator: "count", args: [] },
+ },
+ ],
+ breakouts: [
+ {
+ name: "LATITUDE",
+ binningCount: "auto",
+ },
+ {
+ name: "LONGITUDE",
+ binningCount: "auto",
+ },
+ ],
},
],
});
@@ -208,11 +377,22 @@ describe("defaultDisplay", () => {
});
it("returns 'map' display with 'pin' type for queries with 1 aggregation and 2 un-binned breakouts by coordinates", () => {
- const query = createQueryWithClauses({
- aggregations: [{ operatorName: "count" }],
- breakouts: [
- { columnName: "LATITUDE", tableName: "PEOPLE" },
- { columnName: "LONGITUDE", tableName: "PEOPLE" },
+ const query = createTestQuery(SAMPLE_PROVIDER, {
+ databaseId: SAMPLE_DATABASE.id,
+ stages: [
+ {
+ source: {
+ type: "table",
+ id: ORDERS_ID,
+ },
+ aggregations: [
+ {
+ name: "Count",
+ value: { type: "operator", operator: "count", args: [] },
+ },
+ ],
+ breakouts: [{ name: "LATITUDE" }, { name: "LONGITUDE" }],
+ },
],
});
@@ -225,15 +405,28 @@ describe("defaultDisplay", () => {
});
it("returns 'map' display with 'pin' type for queries with 1 aggregation and 2 breakouts by coordinates - 1 binned, 1 unbinned", () => {
- const query = createQueryWithClauses({
- aggregations: [{ operatorName: "count" }],
- breakouts: [
+ const query = createTestQuery(SAMPLE_PROVIDER, {
+ databaseId: SAMPLE_DATABASE.id,
+ stages: [
{
- columnName: "LATITUDE",
- tableName: "PEOPLE",
- binningStrategyName: "Auto bin",
+ source: {
+ type: "table",
+ id: ORDERS_ID,
+ },
+ aggregations: [
+ {
+ name: "Count",
+ value: { type: "operator", operator: "count", args: [] },
+ },
+ ],
+ breakouts: [
+ {
+ name: "LATITUDE",
+ binningCount: "auto",
+ },
+ { name: "LONGITUDE" },
+ ],
},
- { columnName: "LONGITUDE", tableName: "PEOPLE" },
],
});
@@ -246,11 +439,25 @@ describe("defaultDisplay", () => {
});
it("returns 'bar' display for queries with 1 aggregation and 2 breakouts by category", () => {
- const query = createQueryWithClauses({
- aggregations: [{ operatorName: "count" }],
- breakouts: [
- { columnName: "CATEGORY", tableName: "PRODUCTS" },
- { columnName: "VENDOR", tableName: "PRODUCTS" },
+ const query = createTestQuery(SAMPLE_PROVIDER, {
+ databaseId: SAMPLE_DATABASE.id,
+ stages: [
+ {
+ source: {
+ type: "table",
+ id: ORDERS_ID,
+ },
+ aggregations: [
+ {
+ name: "Count",
+ value: { type: "operator", operator: "count", args: [] },
+ },
+ ],
+ breakouts: [
+ { name: "CATEGORY", groupName: "Product" },
+ { name: "VENDOR", groupName: "Product" },
+ ],
+ },
],
});
@@ -258,11 +465,29 @@ describe("defaultDisplay", () => {
});
it("returns 'table' display by default", () => {
- const query = createQueryWithClauses({
- aggregations: [{ operatorName: "count" }, { operatorName: "cum-count" }],
- breakouts: [
- { columnName: "LATITUDE", tableName: "PEOPLE" },
- { columnName: "LONGITUDE", tableName: "PEOPLE" },
+ const query = createTestQuery(SAMPLE_PROVIDER, {
+ databaseId: SAMPLE_DATABASE.id,
+ stages: [
+ {
+ source: {
+ type: "table",
+ id: ORDERS_ID,
+ },
+ aggregations: [
+ {
+ name: "Count",
+ value: { type: "operator", operator: "count", args: [] },
+ },
+ {
+ name: "Cumulative Count",
+ value: { type: "operator", operator: "cum-count", args: [] },
+ },
+ ],
+ breakouts: [
+ { name: "LATITUDE", groupName: "User" },
+ { name: "LONGITUDE", groupName: "User" },
+ ],
+ },
],
});