Skip to content

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

Remove deprecated unit test helpers (#69275)

Romeo Van Snickc463756c6026
diff --git a/e2e/test/scenarios/dashboard-filters-2/shared/dashboard-filters-query-stages.ts b/e2e/test/scenarios/dashboard-filters-2/shared/dashboard-filters-query-stages.ts
index 4fd81366eab..7e287022cc5 100644
--- a/e2e/test/scenarios/dashboard-filters-2/shared/dashboard-filters-query-stages.ts
+++ b/e2e/test/scenarios/dashboard-filters-2/shared/dashboard-filters-query-stages.ts
@@ -325,31 +325,31 @@ export function createQ9Query(source: Card): StructuredQuery {
type CreateQuery = (source: Card) => StructuredQuery;
export function createAndVisitDashboardWithCardMatrix(
- createQuery: CreateQuery,
+ createQueryFromCard: CreateQuery,
) {
cy.then(function () {
H.createQuestion({
type: "question",
- query: createQuery(this.baseQuestion),
+ query: createQueryFromCard(this.baseQuestion),
name: "Question-based Question",
}).then((response) => cy.wrap(response.body).as("qbq"));
H.createQuestion({
type: "question",
- query: createQuery(this.baseModel),
+ query: createQueryFromCard(this.baseModel),
name: "Model-based Question",
}).then((response) => cy.wrap(response.body).as("mbq"));
H.createQuestion({
type: "model",
name: "Question-based Model",
- query: createQuery(this.baseQuestion),
+ query: createQueryFromCard(this.baseQuestion),
}).then((response) => cy.wrap(response.body).as("qbm"));
H.createQuestion({
type: "model",
name: "Model-based Model",
- query: createQuery(this.baseModel),
+ query: createQueryFromCard(this.baseModel),
}).then((response) => cy.wrap(response.body).as("mbm"));
});
diff --git a/frontend/src/metabase-lib/breakout.unit.spec.ts b/frontend/src/metabase-lib/breakout.unit.spec.ts
index 8091d1d9fc8..300e1d12fc2 100644
--- a/frontend/src/metabase-lib/breakout.unit.spec.ts
+++ b/frontend/src/metabase-lib/breakout.unit.spec.ts
@@ -1,11 +1,34 @@
import { checkNotNull } from "metabase/lib/types";
import * as Lib from "metabase-lib";
-import { columnFinder, createQuery, findTemporalBucket } from "./test-helpers";
+import {
+ DEFAULT_TEST_QUERY,
+ SAMPLE_PROVIDER,
+ columnFinder,
+} from "./test-helpers";
+
+const findTemporalBucket = (
+ query: Lib.Query,
+ column: Lib.ColumnMetadata,
+ bucketName: string,
+) => {
+ if (bucketName === "Don't bin") {
+ return null;
+ }
+
+ const buckets = Lib.availableTemporalBuckets(query, 0, column);
+ const bucket = buckets.find(
+ (bucket) => Lib.displayInfo(query, 0, bucket).displayName === bucketName,
+ );
+ if (!bucket) {
+ throw new Error(`Could not find temporal bucket ${bucketName}`);
+ }
+ return bucket;
+};
describe("breakout", () => {
describe("add breakout", () => {
- const query = createQuery();
+ const query = Lib.createTestQuery(SAMPLE_PROVIDER, DEFAULT_TEST_QUERY);
const findBreakoutableColumn = columnFinder(
query,
Lib.breakoutableColumns(query, 0),
@@ -27,7 +50,7 @@ describe("breakout", () => {
});
it("should preserve breakout positions between v1-v2 roundtrip", () => {
- const query = createQuery();
+ const query = Lib.createTestQuery(SAMPLE_PROVIDER, DEFAULT_TEST_QUERY);
const taxColumn = findBreakoutableColumn("ORDERS", "TAX");
const nextQuery = Lib.breakout(query, 0, taxColumn);
const nextQueryColumns = Lib.breakoutableColumns(nextQuery, 0);
@@ -40,9 +63,10 @@ describe("breakout", () => {
breakoutPositions: [0],
});
- const roundtripQuery = createQuery({
- query: Lib.toJsQuery(nextQuery),
- });
+ const roundtripQuery = Lib.fromJsQuery(
+ SAMPLE_PROVIDER,
+ Lib.toJsQuery(nextQuery),
+ );
const roundtripQueryColumns = Lib.breakoutableColumns(roundtripQuery, 0);
const roundtripTaxColumn = columnFinder(
roundtripQuery,
@@ -98,7 +122,7 @@ describe("breakout", () => {
});
describe("replace breakout", () => {
- const query = createQuery();
+ const query = Lib.createTestQuery(SAMPLE_PROVIDER, DEFAULT_TEST_QUERY);
const findBreakoutableColumn = columnFinder(
query,
Lib.breakoutableColumns(query, 0),
@@ -127,7 +151,7 @@ describe("breakout", () => {
});
describe("remove breakout", () => {
- const query = createQuery();
+ const query = Lib.createTestQuery(SAMPLE_PROVIDER, DEFAULT_TEST_QUERY);
const findBreakoutableColumn = columnFinder(
query,
Lib.breakoutableColumns(query, 0),
diff --git a/frontend/src/metabase-lib/comparison.unit.spec.ts b/frontend/src/metabase-lib/comparison.unit.spec.ts
index dfb846c9c00..4e068ec7458 100644
--- a/frontend/src/metabase-lib/comparison.unit.spec.ts
+++ b/frontend/src/metabase-lib/comparison.unit.spec.ts
@@ -1,22 +1,33 @@
import * as Lib from "metabase-lib";
+import { ORDERS_ID } from "metabase-types/api/mocks/presets";
-import { createQueryWithClauses } from "./test-helpers";
+import { SAMPLE_PROVIDER } from "./test-helpers";
describe("findColumnIndexesFromLegacyRefs", () => {
const stageIndex = -1;
it("should match columns that differ only by temporal buckets", () => {
- const query = createQueryWithClauses({
- breakouts: [
+ const query = Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
{
- tableName: "ORDERS",
- columnName: "CREATED_AT",
- temporalBucketName: "Year",
- },
- {
- tableName: "ORDERS",
- columnName: "CREATED_AT",
- temporalBucketName: "Month",
+ source: {
+ type: "table",
+ id: ORDERS_ID,
+ },
+ breakouts: [
+ {
+ type: "column",
+ sourceName: "ORDERS",
+ name: "CREATED_AT",
+ unit: "year",
+ },
+ {
+ type: "column",
+ sourceName: "ORDERS",
+ name: "CREATED_AT",
+ unit: "month",
+ },
+ ],
},
],
});
@@ -31,17 +42,27 @@ describe("findColumnIndexesFromLegacyRefs", () => {
});
it("should match columns that differ only by binning", () => {
- const query = createQueryWithClauses({
- breakouts: [
- {
- tableName: "ORDERS",
- columnName: "TOTAL",
- binningStrategyName: "10 bins",
- },
+ const query = Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
{
- tableName: "ORDERS",
- columnName: "TOTAL",
- binningStrategyName: "50 bins",
+ source: {
+ type: "table",
+ id: ORDERS_ID,
+ },
+ breakouts: [
+ {
+ type: "column",
+ sourceName: "ORDERS",
+ name: "TOTAL",
+ bins: 10,
+ },
+ {
+ type: "column",
+ sourceName: "ORDERS",
+ name: "TOTAL",
+ bins: 50,
+ },
+ ],
},
],
});
diff --git a/frontend/src/metabase-lib/order_by.unit.spec.ts b/frontend/src/metabase-lib/order_by.unit.spec.ts
index 08d1c4cba07..f04a327cba6 100644
--- a/frontend/src/metabase-lib/order_by.unit.spec.ts
+++ b/frontend/src/metabase-lib/order_by.unit.spec.ts
@@ -2,16 +2,32 @@ import { createMockMetadata } from "__support__/metadata";
import * as Lib from "metabase-lib";
import { createMockCard } from "metabase-types/api/mocks";
import {
+ ORDERS_ID,
SAMPLE_DB_ID,
createProductsTitleField,
createSampleDatabase,
} from "metabase-types/api/mocks/presets";
-import { columnFinder, createQuery } from "./test-helpers";
+import {
+ DEFAULT_TEST_QUERY,
+ SAMPLE_PROVIDER,
+ columnFinder,
+ createMetadataProvider,
+} from "./test-helpers";
describe("order by", () => {
describe("orderableColumns", () => {
- const query = createQuery();
+ const query = Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
+ {
+ source: {
+ type: "table",
+ id: ORDERS_ID,
+ },
+ },
+ ],
+ });
+
const findOrderableColumn = columnFinder(
query,
Lib.orderableColumns(query, 0),
@@ -79,15 +95,20 @@ describe("order by", () => {
databases: [createSampleDatabase()],
questions: [card],
});
-
- const query = createQuery({
+ const provider = createMetadataProvider({
databaseId: SAMPLE_DB_ID,
metadata,
- query: {
- type: "query",
- database: SAMPLE_DB_ID,
- query: { "source-table": `card__${card.id}` },
- },
+ });
+
+ const query = Lib.createTestQuery(provider, {
+ stages: [
+ {
+ source: {
+ type: "card",
+ id: card.id,
+ },
+ },
+ ],
});
const columns = Lib.orderableColumns(query, 0);
@@ -115,7 +136,7 @@ describe("order by", () => {
});
it("should preserve order-by positions between v1-v2 roundtrip", () => {
- const query = createQuery();
+ const query = Lib.createTestQuery(SAMPLE_PROVIDER, DEFAULT_TEST_QUERY);
const taxColumn = findOrderableColumn("ORDERS", "TAX");
const nextQuery = Lib.orderBy(query, 0, taxColumn);
const nextQueryColumns = Lib.orderableColumns(nextQuery, 0);
@@ -128,9 +149,10 @@ describe("order by", () => {
0,
);
- const roundtripQuery = createQuery({
- query: Lib.toJsQuery(nextQuery),
- });
+ const roundtripQuery = Lib.fromJsQuery(
+ SAMPLE_PROVIDER,
+ Lib.toJsQuery(nextQuery),
+ );
const roundtripQueryColumns = Lib.orderableColumns(roundtripQuery, 0);
const roundtripTaxColumn = columnFinder(
roundtripQuery,
@@ -144,7 +166,7 @@ describe("order by", () => {
});
describe("add order by", () => {
- const query = createQuery();
+ const query = Lib.createTestQuery(SAMPLE_PROVIDER, DEFAULT_TEST_QUERY);
const findOrderableColumn = columnFinder(
query,
Lib.orderableColumns(query, 0),
@@ -167,7 +189,7 @@ describe("order by", () => {
});
describe("replace order by", () => {
- const query = createQuery();
+ const query = Lib.createTestQuery(SAMPLE_PROVIDER, DEFAULT_TEST_QUERY);
const findOrderableColumn = columnFinder(
query,
Lib.orderableColumns(query, 0),
@@ -197,7 +219,7 @@ describe("order by", () => {
});
describe("remove order by", () => {
- const query = createQuery();
+ const query = Lib.createTestQuery(SAMPLE_PROVIDER, DEFAULT_TEST_QUERY);
const findOrderableColumn = columnFinder(
query,
Lib.orderableColumns(query, 0),
diff --git a/frontend/src/metabase-lib/query.unit.spec.ts b/frontend/src/metabase-lib/query.unit.spec.ts
index ce0d70b5b33..59018fd5cbf 100644
--- a/frontend/src/metabase-lib/query.unit.spec.ts
+++ b/frontend/src/metabase-lib/query.unit.spec.ts
@@ -1,4 +1,5 @@
import * as Lib from "metabase-lib";
+import type { DatasetQuery } from "metabase-types/api";
import {
ORDERS_ID,
PEOPLE_ID,
@@ -7,13 +8,20 @@ import {
} from "metabase-types/api/mocks/presets";
import {
- DEFAULT_QUERY,
+ DEFAULT_TEST_QUERY,
SAMPLE_DATABASE,
SAMPLE_METADATA,
SAMPLE_PROVIDER,
- createQuery,
} from "./test-helpers";
+const DEFAULT_QUERY: DatasetQuery = {
+ database: SAMPLE_DATABASE.id,
+ type: "query",
+ query: {
+ "source-table": ORDERS_ID,
+ },
+};
+
describe("fromJsQuery", () => {
// this is a very important optimization that the FE heavily relies upon
it("should return the same object for the same database id, query, and metadata", () => {
@@ -29,26 +37,37 @@ describe("fromJsQuery", () => {
describe("toLegacyQuery", () => {
it("should serialize a query", () => {
- const query = createQuery();
+ const query = Lib.createTestQuery(SAMPLE_PROVIDER, DEFAULT_TEST_QUERY);
expect(Lib.toLegacyQuery(query)).toEqual(DEFAULT_QUERY);
});
});
describe("suggestedName", () => {
it("should suggest a query name", () => {
- const query = createQuery();
+ const query = Lib.createTestQuery(SAMPLE_PROVIDER, DEFAULT_TEST_QUERY);
expect(Lib.suggestedName(query)).toBe("Orders");
});
});
describe("stageIndexes", () => {
it("should return stage indexes for a single-stage query", () => {
- const query = createQuery();
+ const query = Lib.createTestQuery(SAMPLE_PROVIDER, DEFAULT_TEST_QUERY);
expect(Lib.stageIndexes(query)).toEqual([0]);
});
it("should return stage indexes for a multi-stage query", () => {
- const query = Lib.appendStage(Lib.appendStage(createQuery()));
+ const query = Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
+ {
+ source: {
+ type: "table",
+ id: PRODUCTS_ID,
+ },
+ },
+ {},
+ {},
+ ],
+ });
expect(Lib.stageIndexes(query)).toEqual([0, 1, 2]);
});
});
diff --git a/frontend/src/metabase-lib/test-helpers.ts b/frontend/src/metabase-lib/test-helpers.ts
index 44dbbfb9d3f..b1097a5e430 100644
--- a/frontend/src/metabase-lib/test-helpers.ts
+++ b/frontend/src/metabase-lib/test-helpers.ts
@@ -1,15 +1,13 @@
/* istanbul ignore file */
import { createMockMetadata } from "__support__/metadata";
-import { checkNotNull } from "metabase/lib/types";
import * as Lib from "metabase-lib";
import type Metadata from "metabase-lib/v1/metadata/Metadata";
import type {
DatabaseId,
DatasetColumn,
- DatasetQuery,
RowValue,
- TableId,
+ TestQuerySpec,
} from "metabase-types/api";
import {
ORDERS_ID,
@@ -29,34 +27,21 @@ type MetadataProviderOpts = {
metadata?: Metadata;
};
-function createMetadataProvider({
+export function createMetadataProvider({
databaseId = SAMPLE_DATABASE.id,
metadata = SAMPLE_METADATA,
}: MetadataProviderOpts = {}) {
return Lib.metadataProvider(databaseId, metadata);
}
-export const DEFAULT_QUERY: DatasetQuery = {
- database: SAMPLE_DATABASE.id,
- type: "query",
- query: {
- "source-table": ORDERS_ID,
- },
+export const DEFAULT_TEST_QUERY: TestQuerySpec = {
+ stages: [
+ {
+ source: { type: "table", id: ORDERS_ID },
+ },
+ ],
};
-type QueryOpts = MetadataProviderOpts & {
- query?: DatasetQuery;
-};
-
-export function createQuery({
- databaseId = SAMPLE_DATABASE.id,
- metadata = SAMPLE_METADATA,
- query = DEFAULT_QUERY,
-}: QueryOpts = {}) {
- const metadataProvider = createMetadataProvider({ databaseId, metadata });
- return Lib.fromJsQuery(metadataProvider, query);
-}
-
export const columnFinder =
(query: Lib.Query, columns: Lib.ColumnMetadata[]) =>
(
@@ -83,104 +68,6 @@ export const columnFinder =
return column;
};
-export const findBinningStrategy = (
- query: Lib.Query,
- column: Lib.ColumnMetadata,
- bucketName: string,
-) => {
- if (bucketName === "Don't bin") {
- return null;
- }
- const buckets = Lib.availableBinningStrategies(query, 0, column);
- const bucket = buckets.find(
- (bucket) => Lib.displayInfo(query, 0, bucket).displayName === bucketName,
- );
- if (!bucket) {
- throw new Error(`Could not find binning strategy ${bucketName}`);
- }
- return bucket;
-};
-
-export const findTemporalBucket = (
- query: Lib.Query,
- column: Lib.ColumnMetadata,
- bucketName: string,
-) => {
- if (bucketName === "Don't bin") {
- return null;
- }
-
- const buckets = Lib.availableTemporalBuckets(query, 0, column);
- const bucket = buckets.find(
- (bucket) => Lib.displayInfo(query, 0, bucket).displayName === bucketName,
- );
- if (!bucket) {
- throw new Error(`Could not find temporal bucket ${bucketName}`);
- }
- return bucket;
-};
-
-export const findAggregationOperator = (
- query: Lib.Query,
- operatorShortName: string,
-) => {
- const operators = Lib.availableAggregationOperators(query, 0);
- const operator = operators.find(
- (operator) =>
- Lib.displayInfo(query, 0, operator).shortName === operatorShortName,
- );
- if (!operator) {
- throw new Error(`Could not find aggregation operator ${operatorShortName}`);
- }
- return operator;
-};
-
-export const findSegment = (query: Lib.Query, segmentName: string) => {
- const stageIndex = 0;
- const segment = Lib.availableSegments(query, stageIndex).find(
- (segment) =>
- Lib.displayInfo(query, stageIndex, segment).displayName === segmentName,
- );
- if (!segment) {
- throw new Error(`Could not find segment ${segmentName}`);
- }
- return segment;
-};
-
-function withTemporalBucketAndBinningStrategy(
- query: Lib.Query,
- column: Lib.ColumnMetadata,
- temporalBucketName = "Don't bin",
- binningStrategyName = "Don't bin",
-) {
- return Lib.withTemporalBucket(
- Lib.withBinning(
- column,
- findBinningStrategy(query, column, binningStrategyName),
- ),
- findTemporalBucket(query, column, temporalBucketName),
- );
-}
-
-type AggregationClauseOpts =
- | {
- operatorName: string;
- tableName?: never;
- columnName?: never;
- }
- | {
- operatorName: string;
- tableName: string;
- columnName: string;
- };
-
-interface BreakoutClauseOpts {
- columnName: string;
- tableName?: string;
- temporalBucketName?: string;
- binningStrategyName?: string;
-}
-
export interface ExpressionClauseOpts {
name: string;
operator: Lib.ExpressionOperator;
@@ -188,82 +75,6 @@ export interface ExpressionClauseOpts {
options?: Lib.ExpressionOptions | null;
}
-interface OrderByClauseOpts {
- columnName: string;
- tableName: string;
- direction: Lib.OrderByDirection;
-}
-
-interface QueryWithClausesOpts {
- query?: Lib.Query;
- expressions?: ExpressionClauseOpts[];
- aggregations?: AggregationClauseOpts[];
- breakouts?: BreakoutClauseOpts[];
- orderBys?: OrderByClauseOpts[];
-}
-
-export function createQueryWithClauses({
- query = createQuery(),
- expressions = [],
- aggregations = [],
- breakouts = [],
- orderBys = [],
-}: QueryWithClausesOpts) {
- const queryWithExpressions = expressions.reduce((query, expression) => {
- return Lib.expression(
- query,
- -1,
- expression.name,
- Lib.expressionClause(
- expression.operator,
- expression.args,
- expression.options,
- ),
- );
- }, query);
-
- const queryWithAggregations = aggregations.reduce((query, aggregation) => {
- return Lib.aggregate(
- query,
- -1,
- Lib.aggregationClause(
- findAggregationOperator(query, aggregation.operatorName),
- aggregation.columnName && aggregation.tableName
- ? columnFinder(query, Lib.visibleColumns(query, -1))(
- aggregation.tableName,
- aggregation.columnName,
- )
- : undefined,
- ),
- );
- }, queryWithExpressions);
-
- const queryWithBreakouts = breakouts.reduce((query, breakout) => {
- const breakoutColumn = columnFinder(
- query,
- Lib.breakoutableColumns(query, -1),
- )(breakout.tableName, breakout.columnName);
- return Lib.breakout(
- query,
- -1,
- withTemporalBucketAndBinningStrategy(
- query,
- breakoutColumn,
- breakout.temporalBucketName,
- breakout.binningStrategyName,
- ),
- );
- }, queryWithAggregations);
-
- return orderBys.reduce((query, orderBy) => {
- const orderByColumn = columnFinder(query, Lib.orderableColumns(query, -1))(
- orderBy.tableName,
- orderBy.columnName,
- );
- return Lib.orderBy(query, -1, orderByColumn, orderBy.direction);
- }, queryWithBreakouts);
-}
-
export const queryDrillThru = (
query: Lib.Query,
stageIndex: number,
@@ -306,44 +117,6 @@ interface ColumnClickObjectOpts {
column: DatasetColumn;
}
-export const getJoinQueryHelpers = (
- query: Lib.Query,
- stageIndex: number,
- tableId: TableId,
-) => {
- const table = checkNotNull(Lib.tableOrCardMetadata(query, tableId));
-
- const findLHSColumn = columnFinder(
- query,
- Lib.joinConditionLHSColumns(query, stageIndex),
- );
- const findRHSColumn = columnFinder(
- query,
- Lib.joinConditionRHSColumns(query, stageIndex, table),
- );
-
- const defaultStrategy = Lib.availableJoinStrategies(query, stageIndex).find(
- (strategy) => Lib.displayInfo(query, stageIndex, strategy).default,
- );
-
- if (!defaultStrategy) {
- throw new Error("No default strategy found");
- }
-
- const defaultOperator = Lib.joinConditionOperators(query, stageIndex)[0];
- if (!defaultOperator) {
- throw new Error("No default operator found");
- }
-
- return {
- table,
- defaultStrategy,
- defaultOperator,
- findLHSColumn,
- findRHSColumn,
- };
-};
-
export function createColumnClickObject({
column,
}: ColumnClickObjectOpts): Lib.ClickObject {
diff --git a/frontend/src/metabase-lib/v1/parameters/utils/targets.unit.spec.ts b/frontend/src/metabase-lib/v1/parameters/utils/targets.unit.spec.ts
index 83547f2d70e..3a7c9d802cb 100644
--- a/frontend/src/metabase-lib/v1/parameters/utils/targets.unit.spec.ts
+++ b/frontend/src/metabase-lib/v1/parameters/utils/targets.unit.spec.ts
@@ -2,10 +2,9 @@ import { createMockMetadata } from "__support__/metadata";
import { checkNotNull } from "metabase/lib/types";
import * as Lib from "metabase-lib";
import {
- columnFinder,
- createQuery,
- createQueryWithClauses,
- getJoinQueryHelpers,
+ DEFAULT_TEST_QUERY,
+ SAMPLE_PROVIDER,
+ createMetadataProvider,
} from "metabase-lib/test-helpers";
import Question from "metabase-lib/v1/Question";
import type Database from "metabase-lib/v1/metadata/Database";
@@ -32,6 +31,7 @@ import {
createMockTemplateTag,
} from "metabase-types/api/mocks";
import {
+ ORDERS_ID,
PRODUCTS,
PRODUCTS_ID,
REVIEWS_ID,
@@ -55,60 +55,93 @@ const metadata = createMockMetadata({
const db = metadata.database(SAMPLE_DB_ID) as Database;
const productsTable = metadata.table(PRODUCTS_ID) as Table;
-
-const queryOrders = createQuery();
-
-const queryNonDateBreakout = createQueryWithClauses({
- aggregations: [{ operatorName: "count" }],
- breakouts: [{ tableName: "ORDERS", columnName: "QUANTITY" }],
+const provider = createMetadataProvider({
+ databaseId: db.id,
+ metadata,
});
-const query1DateBreakout = createQueryWithClauses({
- aggregations: [{ operatorName: "count" }],
- breakouts: [
+const queryOrders = Lib.createTestQuery(provider, DEFAULT_TEST_QUERY);
+
+const queryNonDateBreakout = Lib.createTestQuery(provider, {
+ stages: [
{
- tableName: "ORDERS",
- columnName: "CREATED_AT",
- temporalBucketName: "Month",
+ source: { type: "table", id: ORDERS_ID },
+ aggregations: [{ type: "operator", operator: "count", args: [] }],
+ breakouts: [
+ {
+ type: "column",
+ name: "QUANTITY",
+ sourceName: "ORDERS",
+ },
+ ],
},
],
});
-const query2DateBreakouts = createQueryWithClauses({
- aggregations: [{ operatorName: "count" }],
- breakouts: [
+const query1DateBreakout = Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
{
- tableName: "ORDERS",
- columnName: "CREATED_AT",
- temporalBucketName: "Month",
+ source: { type: "table", id: ORDERS_ID },
+ aggregations: [{ type: "operator", operator: "count" }],
+ breakouts: [
+ {
+ type: "column",
+ name: "CREATED_AT",
+ sourceName: "ORDERS",
+ unit: "month",
+ },
+ ],
},
+ ],
+});
+
+const query2DateBreakouts = Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
{
- tableName: "PRODUCTS",
- columnName: "CREATED_AT",
- temporalBucketName: "Month",
+ source: { type: "table", id: ORDERS_ID },
+ aggregations: [{ type: "operator", operator: "count" }],
+ breakouts: [
+ {
+ type: "column",
+ name: "CREATED_AT",
+ sourceName: "ORDERS",
+ unit: "month",
+ },
+ {
+ type: "column",
+ name: "CREATED_AT",
+ sourceName: "PRODUCTS",
+ unit: "month",
+ },
+ ],
},
],
});
-const queryDateBreakoutsMultiStage = createQueryWithClauses({
- query: Lib.appendStage(
- createQueryWithClauses({
- aggregations: [{ operatorName: "count" }],
+const queryDateBreakoutsMultiStage = Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
+ {
+ source: { type: "table", id: ORDERS_ID },
+ aggregations: [{ type: "operator", operator: "count" }],
breakouts: [
{
- tableName: "ORDERS",
- columnName: "CREATED_AT",
- temporalBucketName: "Month",
+ type: "column",
+ name: "CREATED_AT",
+ sourceName: "ORDERS",
+ unit: "month",
},
],
- }),
- ),
- aggregations: [{ operatorName: "count" }],
- breakouts: [
+ },
{
- tableName: "ORDERS",
- columnName: "CREATED_AT",
- temporalBucketName: "Year",
+ aggregations: [{ type: "operator", operator: "count" }],
+ breakouts: [
+ {
+ type: "column",
+ sourceName: "ORDERS",
+ name: "CREATED_AT",
+ unit: "year",
+ },
+ ],
},
],
});
@@ -576,107 +609,210 @@ describe("parameters/utils/targets", () => {
});
function createComplex1StageQuery() {
- const baseQuery = ordersJoinReviewsOnProductId();
- const findColumn = columnFinder(baseQuery, Lib.visibleColumns(baseQuery, -1));
- const userBirthdayColumn = findColumn("PEOPLE", "BIRTH_DATE");
-
- return createQueryWithClauses({
- query: baseQuery,
- expressions: [
- {
- name: "User's 18th birthday",
- operator: "datetime-add",
- args: [checkNotNull(userBirthdayColumn), 18, "year"],
- },
- ],
- aggregations: [
- { operatorName: "count" },
- { operatorName: "sum", tableName: "ORDERS", columnName: "TOTAL" },
- ],
- breakouts: [
+ return Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
{
- tableName: "ORDERS",
- columnName: "CREATED_AT",
- temporalBucketName: "Month",
- },
- {
- tableName: "PRODUCTS",
- columnName: "CREATED_AT",
- temporalBucketName: "Year",
- },
- {
- tableName: "REVIEWS",
- columnName: "CREATED_AT",
- temporalBucketName: "Quarter",
- },
- {
- columnName: "User's 18th birthday",
+ source: { type: "table", id: ORDERS_ID },
+ joins: [
+ {
+ source: { type: "table", id: REVIEWS_ID },
+ strategy: "left-join",
+ conditions: [
+ {
+ operator: "=",
+ left: {
+ type: "column",
+ name: "PRODUCT_ID",
+ sourceName: "ORDERS",
+ },
+ right: {
+ type: "column",
+ name: "PRODUCT_ID",
+ sourceName: "REVIEWS",
+ },
+ },
+ ],
+ },
+ ],
+ expressions: [
+ {
+ name: "User's 18th birthday",
+ value: {
+ type: "operator",
+ operator: "datetime-add",
+ args: [
+ { type: "column", name: "BIRTH_DATE", sourceName: "PEOPLE" },
+ { type: "literal", value: 18 },
+ { type: "literal", value: "year" },
+ ],
+ },
+ },
+ ],
+ aggregations: [
+ { type: "operator", operator: "count" },
+ {
+ type: "operator",
+ operator: "sum",
+ args: [{ type: "column", name: "TOTAL", sourceName: "ORDERS" }],
+ },
+ ],
+ breakouts: [
+ {
+ type: "column",
+ name: "CREATED_AT",
+ sourceName: "ORDERS",
+ unit: "month",
+ },
+ {
+ type: "column",
+ name: "CREATED_AT",
+ sourceName: "PRODUCTS",
+ unit: "year",
+ index: 0,
+ },
+ {
+ type: "column",
+ name: "CREATED_AT",
+ sourceName: "REVIEWS",
+ unit: "quarter",
+ },
+ {
+ type: "column",
+ name: "User's 18th birthday",
+ },
+ ],
},
],
});
}
function createComplex2StageQuery() {
- const baseQuery = Lib.appendStage(createComplex1StageQuery());
- const findColumn = columnFinder(baseQuery, Lib.visibleColumns(baseQuery, -1));
- const countColumn = findColumn(null, "count");
-
- const stageIndex = -1;
- const {
- table,
- defaultStrategy,
- defaultOperator,
- findLHSColumn,
- findRHSColumn,
- } = getJoinQueryHelpers(baseQuery, stageIndex, REVIEWS_ID);
-
- const createdAt = findLHSColumn("ORDERS", "CREATED_AT");
- const reviewsCreatedAt = findRHSColumn("REVIEWS", "CREATED_AT");
- const condition = Lib.joinConditionClause(
- defaultOperator,
- reviewsCreatedAt,
- createdAt,
- );
- const join = Lib.joinClause(table, [condition], defaultStrategy);
- const queryWithJoin = Lib.join(baseQuery, stageIndex, join);
-
- return createQueryWithClauses({
- query: queryWithJoin,
- expressions: [
+ return Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
+ {
+ source: { type: "table", id: ORDERS_ID },
+ joins: [
+ {
+ source: { type: "table", id: REVIEWS_ID },
+ strategy: "left-join",
+ conditions: [
+ {
+ operator: "=",
+ left: {
+ type: "column",
+ name: "PRODUCT_ID",
+ sourceName: "ORDERS",
+ },
+ right: {
+ type: "column",
+ name: "PRODUCT_ID",
+ sourceName: "REVIEWS",
+ },
+ },
+ ],
+ },
+ ],
+ expressions: [
+ {
+ name: "User's 18th birthday",
+ value: {
+ type: "operator",
+ operator: "datetime-add",
+ args: [
+ { type: "column", name: "BIRTH_DATE", sourceName: "PEOPLE" },
+ { type: "literal", value: 18 },
+ { type: "literal", value: "year" },
+ ],
+ },
+ },
+ ],
+ aggregations: [
+ { type: "operator", operator: "count", args: [] },
+ {
+ type: "operator",
+ operator: "sum",
+ args: [
+ {
+ type: "column",
+ name: "TOTAL",
+ sourceName: "ORDERS",
+ },
+ ],
+ },
+ ],
+ breakouts: [
+ {
+ type: "column",
+ name: "CREATED_AT",
+ sourceName: "ORDERS",
+ unit: "month",
+ },
+ {
+ type: "column",
+ name: "CREATED_AT",
+ sourceName: "ORDERS",
+ unit: "year",
+ },
+ {
+ type: "column",
+ name: "CREATED_AT",
+ sourceName: "REVIEWS",
+ unit: "quarter",
+ },
+ {
+ type: "column",
+ name: "User's 18th birthday",
+ },
+ ],
+ },
{
- name: "Count + 1",
- operator: "+",
- args: [checkNotNull(countColumn), 1],
+ joins: [
+ {
+ source: { type: "table", id: REVIEWS_ID },
+ strategy: "left-join",
+ conditions: [
+ {
+ operator: "=",
+ left: {
+ type: "column",
+ name: "CREATED_AT",
+ sourceName: "ORDERS",
+ index: 0,
+ },
+ right: {
+ type: "column",
+ name: "CREATED_AT",
+ sourceName: "REVIEWS",
+ },
+ },
+ ],
+ },
+ ],
+ expressions: [
+ {
+ name: "Count + 1",
+ value: {
+ type: "operator",
+ operator: "+",
+ args: [
+ { type: "column", name: "count" },
+ { type: "literal", value: 1 },
+ ],
+ },
+ },
+ ],
+ aggregations: [{ type: "operator", operator: "count" }],
+ breakouts: [
+ {
+ type: "column",
+ name: "User's 18th birthday",
+ },
+ ],
},
],
- aggregations: [{ operatorName: "count" }],
- breakouts: [{ columnName: "User's 18th birthday" }],
});
}
-function ordersJoinReviewsOnProductId() {
- const stageIndex = -1;
- const {
- table,
- defaultStrategy,
- defaultOperator,
- findLHSColumn,
- findRHSColumn,
- } = getJoinQueryHelpers(queryOrders, stageIndex, REVIEWS_ID);
-
- const productsId = findLHSColumn("ORDERS", "PRODUCT_ID");
- const reviewsProductId = findRHSColumn("REVIEWS", "PRODUCT_ID");
- const condition = Lib.joinConditionClause(
- defaultOperator,
- reviewsProductId,
- productsId,
- );
- const join = Lib.joinClause(table, [condition], defaultStrategy);
- const query = Lib.join(queryOrders, stageIndex, join);
-
- return query;
-}
-
function createUnitOfTimeParameter() {
return createMockParameter({
name: "Time grouping",
diff --git a/frontend/src/metabase-lib/viz/display.unit.spec.ts b/frontend/src/metabase-lib/viz/display.unit.spec.ts
index a6585e9879f..6a40543a96a 100644
--- a/frontend/src/metabase-lib/viz/display.unit.spec.ts
+++ b/frontend/src/metabase-lib/viz/display.unit.spec.ts
@@ -1,82 +1,93 @@
import { createMockMetadata } from "__support__/metadata";
-import type { Field, Table } from "metabase-types/api";
+import * as Lib from "metabase-lib";
import { createMockField, createMockTable } from "metabase-types/api/mocks";
import {
- SAMPLE_DB_ID,
+ ORDERS_ID,
createSampleDatabase,
} from "metabase-types/api/mocks/presets";
-import { createQuery, createQueryWithClauses } from "../test-helpers";
+import {
+ DEFAULT_TEST_QUERY,
+ SAMPLE_PROVIDER,
+ createMetadataProvider,
+} from "../test-helpers";
import { defaultDisplay } from "./display";
+const DATABASE_ID = 1;
const ACCOUNTS_ID = 4;
const ACCOUNTS_COUNTRY_ID = 56;
-const createAccountsTable = (opts?: Partial<Table>): Table =>
- createMockTable({
- id: ACCOUNTS_ID,
- db_id: SAMPLE_DB_ID,
- name: "ACCOUNTS",
- display_name: "Accounts",
- schema: "PUBLIC",
- fields: [createAccountsCountryField()],
- ...opts,
- });
+const ACCOUNTS_COUNTRY = createMockField({
+ id: ACCOUNTS_COUNTRY_ID,
+ table_id: ACCOUNTS_ID,
+ name: "COUNTRY",
+ display_name: "Country",
+ base_type: "type/Text",
+ effective_type: "type/Text",
+ semantic_type: "type/Country",
+ fingerprint: null,
+});
-const createAccountsCountryField = (opts?: Partial<Field>): Field =>
- createMockField({
- id: ACCOUNTS_COUNTRY_ID,
- table_id: ACCOUNTS_ID,
- name: "COUNTRY",
- display_name: "Country",
- base_type: "type/Text",
- effective_type: "type/Text",
- semantic_type: "type/Country",
- fingerprint: null,
- ...opts,
- });
+const ACCOUNTS = createMockTable({
+ id: ACCOUNTS_ID,
+ db_id: DATABASE_ID,
+ name: "ACCOUNTS",
+ display_name: "Accounts",
+ schema: "PUBLIC",
+ fields: [ACCOUNTS_COUNTRY],
+});
-const SAMPLE_DATABASE = createSampleDatabase({
- tables: [createAccountsTable()],
+const DATABASE = createSampleDatabase({
+ id: DATABASE_ID,
+ tables: [ACCOUNTS],
});
-const SAMPLE_METADATA = createMockMetadata({ databases: [SAMPLE_DATABASE] });
+const METADATA = createMockMetadata({ databases: [DATABASE] });
+const PROVIDER = createMetadataProvider({
+ databaseId: DATABASE.id,
+ metadata: 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 = Lib.nativeQuery(
+ DATABASE.id,
+ PROVIDER,
+ "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 = Lib.createTestQuery(SAMPLE_PROVIDER, DEFAULT_TEST_QUERY);
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 = Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
+ {
+ source: { type: "table", id: ORDERS_ID },
+ aggregations: [{ 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 = Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
+ {
+ source: { type: "table", id: ORDERS_ID },
+ aggregations: [{ type: "operator", operator: "count", args: [] }],
+ breakouts: [{ type: "column", name: "STATE", sourceName: "PEOPLE" }],
+ },
+ ],
});
expect(defaultDisplay(query)).toEqual({
@@ -89,19 +100,19 @@ 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 = Lib.createTestQuery(PROVIDER, {
+ stages: [
+ {
+ source: {
+ type: "table",
+ id: ACCOUNTS_ID,
},
+ aggregations: [{ type: "operator", operator: "count", args: [] }],
+ breakouts: [
+ { type: "column", name: "COUNTRY", sourceName: "ACCOUNTS" },
+ ],
},
- }),
- aggregations: [{ operatorName: "count" }],
- breakouts: [{ columnName: "COUNTRY", tableName: "ACCOUNTS" }],
+ ],
});
expect(defaultDisplay(query)).toEqual({
@@ -114,13 +125,22 @@ 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 = Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
{
- columnName: "CREATED_AT",
- tableName: "ORDERS",
- temporalBucketName: "Day of month",
+ source: {
+ type: "table",
+ id: ORDERS_ID,
+ },
+ aggregations: [{ type: "operator", operator: "count" }],
+ breakouts: [
+ {
+ type: "column",
+ name: "CREATED_AT",
+ sourceName: "ORDERS",
+ unit: "day-of-month",
+ },
+ ],
},
],
});
@@ -129,22 +149,35 @@ 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 = Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
+ {
+ source: { type: "table", id: ORDERS_ID },
+ aggregations: [{ type: "operator", operator: "count", args: [] }],
+ breakouts: [
+ { type: "column", name: "CREATED_AT", sourceName: "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 = Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
{
- columnName: "TOTAL",
- tableName: "ORDERS",
- binningStrategyName: "10 bins",
+ source: { type: "table", id: ORDERS_ID },
+ aggregations: [{ type: "operator", operator: "count", args: [] }],
+ breakouts: [
+ {
+ type: "column",
+ name: "TOTAL",
+ sourceName: "ORDERS",
+ bins: 10,
+ },
+ ],
},
],
});
@@ -153,29 +186,46 @@ describe("defaultDisplay", () => {
});
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 = Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
+ {
+ source: { type: "table", id: ORDERS_ID },
+ aggregations: [{ type: "operator", operator: "count", args: [] }],
+ breakouts: [{ type: "column", name: "TOTAL", sourceName: "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 = Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
+ {
+ source: { type: "table", id: ORDERS_ID },
+ aggregations: [{ type: "operator", operator: "count", args: [] }],
+ breakouts: [
+ { type: "column", name: "CATEGORY", sourceName: "PRODUCTS" },
+ ],
+ },
+ ],
});
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 = Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
+ {
+ source: { type: "table", id: ORDERS_ID },
+ aggregations: [{ type: "operator", operator: "count", args: [] }],
+ breakouts: [
+ { type: "column", name: "CREATED_AT", sourceName: "ORDERS" },
+ { type: "column", name: "TOTAL", sourceName: "ORDERS" },
+ ],
+ },
],
});
@@ -183,18 +233,25 @@ 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: [
- {
- columnName: "LATITUDE",
- tableName: "PEOPLE",
- binningStrategyName: "Auto bin",
- },
+ const query = Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
{
- columnName: "LONGITUDE",
- tableName: "PEOPLE",
- binningStrategyName: "Auto bin",
+ source: { type: "table", id: ORDERS_ID },
+ aggregations: [{ type: "operator", operator: "count" }],
+ breakouts: [
+ {
+ type: "column",
+ name: "LATITUDE",
+ sourceName: "PEOPLE",
+ binWidth: "auto",
+ },
+ {
+ type: "column",
+ name: "LONGITUDE",
+ sourceName: "PEOPLE",
+ binWidth: "auto",
+ },
+ ],
},
],
});
@@ -208,11 +265,16 @@ 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 = Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
+ {
+ source: { type: "table", id: ORDERS_ID },
+ aggregations: [{ type: "operator", operator: "count", args: [] }],
+ breakouts: [
+ { type: "column", name: "LATITUDE", sourceName: "PEOPLE" },
+ { type: "column", name: "LONGITUDE", sourceName: "PEOPLE" },
+ ],
+ },
],
});
@@ -225,15 +287,21 @@ 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 = Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
{
- columnName: "LATITUDE",
- tableName: "PEOPLE",
- binningStrategyName: "Auto bin",
+ source: { type: "table", id: ORDERS_ID },
+ aggregations: [{ type: "operator", operator: "count", args: [] }],
+ breakouts: [
+ {
+ type: "column",
+ name: "LATITUDE",
+ sourceName: "PEOPLE",
+ // bins: "auto",
+ },
+ { type: "column", name: "LONGITUDE", sourceName: "PEOPLE" },
+ ],
},
- { columnName: "LONGITUDE", tableName: "PEOPLE" },
],
});
@@ -246,11 +314,16 @@ 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 = Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
+ {
+ source: { type: "table", id: ORDERS_ID },
+ aggregations: [{ type: "operator", operator: "count", args: [] }],
+ breakouts: [
+ { type: "column", name: "CATEGORY", sourceName: "PRODUCTS" },
+ { type: "column", name: "VENDOR", sourceName: "PRODUCTS" },
+ ],
+ },
],
});
@@ -258,11 +331,19 @@ 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 = Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
+ {
+ source: { type: "table", id: ORDERS_ID },
+ aggregations: [
+ { type: "operator", operator: "count", args: [] },
+ { type: "operator", operator: "cum-count", args: [] },
+ ],
+ breakouts: [
+ { type: "column", name: "LATITUDE", sourceName: "PEOPLE" },
+ { type: "column", name: "LONGITUDE", sourceName: "PEOPLE" },
+ ],
+ },
],
});
diff --git a/frontend/src/metabase-types/api/query.ts b/frontend/src/metabase-types/api/query.ts
index f506d412d43..2076e099001 100644
--- a/frontend/src/metabase-types/api/query.ts
+++ b/frontend/src/metabase-types/api/query.ts
@@ -458,6 +458,10 @@ export type TestColumnSpec = {
name: string;
sourceName?: string;
displayName?: string;
+
+ // When the columns cannot be disambiguated with name, sourceName and displayName
+ // use this index to pick one.
+ index?: number;
};
export type TestExpressionSpec =
@@ -490,11 +494,11 @@ export type TestTemporalBucketSpec = {
};
export type TestBinCountSpec = {
- bins?: number;
+ bins?: number | "auto";
};
export type TestBinWidthSpec = {
- binWidth?: number;
+ binWidth?: number | "auto";
};
type TestBinningSpec =
diff --git a/frontend/src/metabase/common/components/AdHocQuestionLoader.unit.spec.js b/frontend/src/metabase/common/components/AdHocQuestionLoader.unit.spec.js
index 7a239094c1a..800ad01a3ac 100644
--- a/frontend/src/metabase/common/components/AdHocQuestionLoader.unit.spec.js
+++ b/frontend/src/metabase/common/components/AdHocQuestionLoader.unit.spec.js
@@ -1,7 +1,11 @@
import { render } from "__support__/ui";
import { delay } from "__support__/utils";
import * as Lib from "metabase-lib";
-import { SAMPLE_METADATA, createQuery } from "metabase-lib/test-helpers";
+import {
+ DEFAULT_TEST_QUERY,
+ SAMPLE_METADATA,
+ SAMPLE_PROVIDER,
+} from "metabase-lib/test-helpers";
import Question from "metabase-lib/v1/Question";
import * as ML_Urls from "metabase-lib/v1/urls";
@@ -23,7 +27,7 @@ describe("AdHocQuestionLoader", () => {
it("should load a question given a questionHash", async () => {
const q = Question.create({ metadata: SAMPLE_METADATA }).setQuery(
- createQuery(),
+ Lib.createTestQuery(SAMPLE_PROVIDER, DEFAULT_TEST_QUERY),
);
const questionHash = ML_Urls.getUrl(q).match(/(#.*)/)[1];
diff --git a/frontend/src/metabase/common/components/AggregationPicker/AggregationPicker.unit.spec.tsx b/frontend/src/metabase/common/components/AggregationPicker/AggregationPicker.unit.spec.tsx
index baa91c40ca0..d131b30dc83 100644
--- a/frontend/src/metabase/common/components/AggregationPicker/AggregationPicker.unit.spec.tsx
+++ b/frontend/src/metabase/common/components/AggregationPicker/AggregationPicker.unit.spec.tsx
@@ -5,15 +5,14 @@ import { createMockMetadata } from "__support__/metadata";
import { createMockEntitiesState } from "__support__/store";
import { renderWithProviders, screen } from "__support__/ui";
import * as Lib from "metabase-lib";
-import { createQuery, createQueryWithClauses } from "metabase-lib/test-helpers";
+import { DEFAULT_TEST_QUERY, SAMPLE_PROVIDER } from "metabase-lib/test-helpers";
import type Metadata from "metabase-lib/v1/metadata/Metadata";
import {
COMMON_DATABASE_FEATURES,
createMockCard,
} from "metabase-types/api/mocks";
import {
- ORDERS,
- SAMPLE_DB_ID,
+ ORDERS_ID,
createOrdersTable,
createPeopleTable,
createProductsTable,
@@ -29,52 +28,81 @@ import {
import { AggregationPicker } from "./AggregationPicker";
function createQueryWithCountAggregation() {
- return createQueryWithClauses({
- aggregations: [{ operatorName: "count" }],
+ return Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
+ {
+ source: {
+ type: "table",
+ id: ORDERS_ID,
+ },
+ aggregations: [{ type: "operator", operator: "count", args: [] }],
+ },
+ ],
});
}
function createQueryWithMaxAggregation() {
- return createQueryWithClauses({
- aggregations: [
- { operatorName: "max", tableName: "ORDERS", columnName: "QUANTITY" },
+ return Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
+ {
+ source: {
+ type: "table",
+ id: ORDERS_ID,
+ },
+
+ aggregations: [
+ {
+ type: "operator",
+ operator: "max",
+ args: [{ type: "column", name: "QUANTITY" }],
+ },
+ ],
+ },
],
});
}
function createQueryWithInlineExpression() {
- return createQuery({
- query: {
- database: SAMPLE_DB_ID,
- type: "query",
- query: {
- aggregation: [
- [
- "aggregation-options",
- ["avg", ["field", ORDERS.QUANTITY, null]],
- { name: "Avg Q", "display-name": "Avg Q" },
- ],
+ return Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
+ {
+ source: {
+ type: "table",
+ id: ORDERS_ID,
+ },
+ aggregations: [
+ {
+ name: "Avg Q",
+ value: {
+ type: "operator",
+ operator: "avg",
+ args: [
+ { type: "column", name: "QUANTITY", sourceName: "ORDERS" },
+ ],
+ },
+ },
],
},
- },
+ ],
});
}
function createQueryWithInlineExpressionWithOperator() {
- return createQuery({
- query: {
- database: SAMPLE_DB_ID,
- type: "query",
- query: {
- aggregation: [
- [
- "aggregation-options",
- ["count"],
- { name: "My count", "display-name": "My count" },
- ],
+ return Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
+ {
+ source: { type: "table", id: ORDERS_ID },
+ aggregations: [
+ {
+ name: "My count",
+ value: {
+ type: "operator",
+ operator: "count",
+ },
+ },
],
},
- },
+ ],
});
}
@@ -115,7 +143,7 @@ function setup({
}),
}),
metadata = createMetadata(),
- query = createQuery({ metadata }),
+ query = Lib.createTestQuery(SAMPLE_PROVIDER, DEFAULT_TEST_QUERY),
allowCustomExpressions,
}: SetupOpts = {}) {
const stageIndex = 0;
diff --git a/frontend/src/metabase/common/components/MetadataInfo/ColumnInfo/ColumnInfo.unit.spec.js b/frontend/src/metabase/common/components/MetadataInfo/ColumnInfo/ColumnInfo.unit.spec.js
index 32c765fc0cb..076cae4b098 100644
--- a/frontend/src/metabase/common/components/MetadataInfo/ColumnInfo/ColumnInfo.unit.spec.js
+++ b/frontend/src/metabase/common/components/MetadataInfo/ColumnInfo/ColumnInfo.unit.spec.js
@@ -3,7 +3,11 @@ import { createMockEntitiesState } from "__support__/store";
import { renderWithProviders, screen } from "__support__/ui";
import { getMetadata } from "metabase/selectors/metadata";
import * as Lib from "metabase-lib";
-import { columnFinder, createQuery } from "metabase-lib/test-helpers";
+import {
+ DEFAULT_TEST_QUERY,
+ SAMPLE_PROVIDER,
+ columnFinder,
+} from "metabase-lib/test-helpers";
import {
PRODUCTS,
PRODUCT_CATEGORY_VALUES,
@@ -29,7 +33,7 @@ function setup(field) {
}
function setupMLv2(table, column) {
- const query = createQuery();
+ const query = Lib.createTestQuery(SAMPLE_PROVIDER, DEFAULT_TEST_QUERY);
const columns = Lib.visibleColumns(query, 0);
const findColumn = columnFinder(query, columns);
const col = findColumn(table, column);
diff --git a/frontend/src/metabase/common/components/MetadataInfo/ColumnInfoIcon/ColumnInfoIcon.unit.spec.tsx b/frontend/src/metabase/common/components/MetadataInfo/ColumnInfoIcon/ColumnInfoIcon.unit.spec.tsx
index 5733816b3bc..df919a8f21c 100644
--- a/frontend/src/metabase/common/components/MetadataInfo/ColumnInfoIcon/ColumnInfoIcon.unit.spec.tsx
+++ b/frontend/src/metabase/common/components/MetadataInfo/ColumnInfoIcon/ColumnInfoIcon.unit.spec.tsx
@@ -1,11 +1,15 @@
import { fireEvent, render, screen, waitFor } from "__support__/ui";
import * as Lib from "metabase-lib";
-import { columnFinder, createQuery } from "metabase-lib/test-helpers";
+import {
+ DEFAULT_TEST_QUERY,
+ SAMPLE_PROVIDER,
+ columnFinder,
+} from "metabase-lib/test-helpers";
import { QueryColumnInfoIcon } from "./ColumnInfoIcon";
function setup(table: string, column: string) {
- const query = createQuery();
+ const query = Lib.createTestQuery(SAMPLE_PROVIDER, DEFAULT_TEST_QUERY);
const columns = Lib.visibleColumns(query, 0);
const findColumn = columnFinder(query, columns);
const col = findColumn(table, column);
diff --git a/frontend/src/metabase/common/components/QueryColumnPicker/BucketPickerPopover/BucketPickerPopover.unit.spec.tsx b/frontend/src/metabase/common/components/QueryColumnPicker/BucketPickerPopover/BucketPickerPopover.unit.spec.tsx
index 65ef2023d18..574729a5603 100644
--- a/frontend/src/metabase/common/components/QueryColumnPicker/BucketPickerPopover/BucketPickerPopover.unit.spec.tsx
+++ b/frontend/src/metabase/common/components/QueryColumnPicker/BucketPickerPopover/BucketPickerPopover.unit.spec.tsx
@@ -2,11 +2,15 @@ import userEvent from "@testing-library/user-event";
import { render, screen, waitFor } from "__support__/ui";
import * as Lib from "metabase-lib";
-import { columnFinder, createQuery } from "metabase-lib/test-helpers";
+import {
+ DEFAULT_TEST_QUERY,
+ SAMPLE_PROVIDER,
+ columnFinder,
+} from "metabase-lib/test-helpers";
import { BucketPickerPopover } from "./BucketPickerPopover";
-const query = createQuery();
+const query = Lib.createTestQuery(SAMPLE_PROVIDER, DEFAULT_TEST_QUERY);
const findColumn = columnFinder(query, Lib.breakoutableColumns(query, 0));
const dateColumn = findColumn("ORDERS", "CREATED_AT");
const numericColumn = findColumn("ORDERS", "TOTAL");
diff --git a/frontend/src/metabase/common/components/QueryColumnPicker/QueryColumnPicker.unit.spec.tsx b/frontend/src/metabase/common/components/QueryColumnPicker/QueryColumnPicker.unit.spec.tsx
index 18588ba1c34..947cb5256ab 100644
--- a/frontend/src/metabase/common/components/QueryColumnPicker/QueryColumnPicker.unit.spec.tsx
+++ b/frontend/src/metabase/common/components/QueryColumnPicker/QueryColumnPicker.unit.spec.tsx
@@ -2,7 +2,12 @@ import userEvent from "@testing-library/user-event";
import { fireEvent, renderWithProviders, screen, within } from "__support__/ui";
import * as Lib from "metabase-lib";
-import { columnFinder, createQuery } from "metabase-lib/test-helpers";
+import {
+ DEFAULT_TEST_QUERY,
+ SAMPLE_PROVIDER,
+ columnFinder,
+} from "metabase-lib/test-helpers";
+import { ORDERS_ID } from "metabase-types/api/mocks/presets";
import type { QueryColumnPickerProps } from "./QueryColumnPicker";
import { QueryColumnPicker } from "./QueryColumnPicker";
@@ -17,16 +22,28 @@ type SetupOpts = Partial<
};
function createQueryWithBreakout() {
- const plainQuery = createQuery();
- const [column] = Lib.breakoutableColumns(plainQuery, 0);
- const query = Lib.breakout(plainQuery, 0, column);
+ const query = Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
+ {
+ source: { type: "table", id: ORDERS_ID },
+ breakouts: [
+ {
+ type: "column",
+ name: "CREATED_AT",
+ sourceName: "ORDERS",
+ },
+ ],
+ },
+ ],
+ });
+
const [clause] = Lib.breakouts(query, 0);
const clauseInfo = Lib.displayInfo(query, 0, clause);
return { query, clause, clauseInfo };
}
function setup({
- query = createQuery(),
+ query = Lib.createTestQuery(SAMPLE_PROVIDER, DEFAULT_TEST_QUERY),
stageIndex = 0,
columns = Lib.breakoutableColumns(query, stageIndex),
hasBinning = true,
diff --git a/frontend/src/metabase/common/utils/columns.unit.spec.ts b/frontend/src/metabase/common/utils/columns.unit.spec.ts
index 1e0bb84a613..cb6a292351a 100644
--- a/frontend/src/metabase/common/utils/columns.unit.spec.ts
+++ b/frontend/src/metabase/common/utils/columns.unit.spec.ts
@@ -1,10 +1,14 @@
import * as Lib from "metabase-lib";
-import { columnFinder, createQuery } from "metabase-lib/test-helpers";
+import {
+ DEFAULT_TEST_QUERY,
+ SAMPLE_PROVIDER,
+ columnFinder,
+} from "metabase-lib/test-helpers";
import { getColumnIcon } from "./columns";
describe("common/utils/columns", () => {
- const query = createQuery();
+ const query = Lib.createTestQuery(SAMPLE_PROVIDER, DEFAULT_TEST_QUERY);
const columns = Lib.orderableColumns(query, 0);
const getColumn = columnFinder(query, columns);
diff --git a/frontend/src/metabase/data-studio/measures/components/MeasureEditor/MeasureEditor.unit.spec.tsx b/frontend/src/metabase/data-studio/measures/components/MeasureEditor/MeasureEditor.unit.spec.tsx
index d85b1fa046c..3542806fd8b 100644
--- a/frontend/src/metabase/data-studio/measures/components/MeasureEditor/MeasureEditor.unit.spec.tsx
+++ b/frontend/src/metabase/data-studio/measures/components/MeasureEditor/MeasureEditor.unit.spec.tsx
@@ -1,10 +1,11 @@
import { renderWithProviders, screen } from "__support__/ui";
-import { createQuery } from "metabase-lib/test-helpers";
+import * as Lib from "metabase-lib";
+import { DEFAULT_TEST_QUERY, SAMPLE_PROVIDER } from "metabase-lib/test-helpers";
import { MeasureEditor } from "./MeasureEditor";
describe("MeasureEditor", () => {
- const query = createQuery();
+ const query = Lib.createTestQuery(SAMPLE_PROVIDER, DEFAULT_TEST_QUERY);
const description = "A sample description";
const onQueryChange = jest.fn();
const onDescriptionChange = jest.fn();
diff --git a/frontend/src/metabase/parameters/utils/mapping-options.unit.spec.js b/frontend/src/metabase/parameters/utils/mapping-options.unit.spec.js
index ca8107dc466..d8fc93c4e88 100644
--- a/frontend/src/metabase/parameters/utils/mapping-options.unit.spec.js
+++ b/frontend/src/metabase/parameters/utils/mapping-options.unit.spec.js
@@ -1,9 +1,6 @@
import { createMockMetadata } from "__support__/metadata";
import * as Lib from "metabase-lib";
-import {
- SAMPLE_METADATA,
- createQueryWithClauses,
-} from "metabase-lib/test-helpers";
+import { SAMPLE_METADATA, SAMPLE_PROVIDER } from "metabase-lib/test-helpers";
import Question from "metabase-lib/v1/Question";
import {
createMockCard,
@@ -778,17 +775,22 @@ describe("getMappingOptionByTarget", () => {
});
it("should not confuse columns from different stages", () => {
- const query = Lib.appendStage(
- createQueryWithClauses({
- breakouts: [
- {
- columnName: "CREATED_AT",
- tableName: "ORDERS",
- temporalBucketName: "Month",
- },
- ],
- }),
- );
+ const query = Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
+ {
+ source: { type: "table", id: ORDERS_ID },
+ breakouts: [
+ {
+ type: "column",
+ sourceName: "ORDERS",
+ name: "CREATED_AT",
+ unit: "month",
+ },
+ ],
+ },
+ {},
+ ],
+ });
const question = Question.create({ metadata: SAMPLE_METADATA }).setQuery(
query,
);
diff --git a/frontend/src/metabase/query_builder/components/NativeQueryEditor/CodeMirrorEditor/CodeMirrorEditor.unit.spec.tsx b/frontend/src/metabase/query_builder/components/NativeQueryEditor/CodeMirrorEditor/CodeMirrorEditor.unit.spec.tsx
index 5ef7ab99406..f9c8bacef8f 100644
--- a/frontend/src/metabase/query_builder/components/NativeQueryEditor/CodeMirrorEditor/CodeMirrorEditor.unit.spec.tsx
+++ b/frontend/src/metabase/query_builder/components/NativeQueryEditor/CodeMirrorEditor/CodeMirrorEditor.unit.spec.tsx
@@ -2,7 +2,8 @@ import fetchMock from "fetch-mock";
import { createMockMetadata } from "__support__/metadata";
import { renderWithProviders, screen } from "__support__/ui";
-import { createQuery } from "metabase-lib/test-helpers";
+import * as Lib from "metabase-lib";
+import { createMetadataProvider } from "metabase-lib/test-helpers";
import type { NativeQuerySnippet } from "metabase-types/api";
import { createSampleDatabase } from "metabase-types/api/mocks/presets";
@@ -30,17 +31,13 @@ function setup({
const metadata = createMockMetadata({
databases: [database],
});
- const query = createQuery({
+ const provider = createMetadataProvider({
+ databaseId: database.id,
metadata,
- query: {
- database: database.id,
- type: "native",
- native: {
- query: text,
- },
- },
});
+ const query = Lib.createTestNativeQuery(provider, { query: text });
+
renderWithProviders(
<CodeMirrorEditor
query={query}
diff --git a/frontend/src/metabase/query_builder/components/expressions/CombineColumns/util.unit.spec.ts b/frontend/src/metabase/query_builder/components/expressions/CombineColumns/util.unit.spec.ts
index a7c818f9184..e633d060533 100644
--- a/frontend/src/metabase/query_builder/components/expressions/CombineColumns/util.unit.spec.ts
+++ b/frontend/src/metabase/query_builder/components/expressions/CombineColumns/util.unit.spec.ts
@@ -1,6 +1,9 @@
import { createMockMetadata } from "__support__/metadata";
import * as Lib from "metabase-lib";
-import { columnFinder, createQuery } from "metabase-lib/test-helpers";
+import {
+ columnFinder,
+ createMetadataProvider,
+} from "metabase-lib/test-helpers";
import {
createMockDatabase,
createMockField,
@@ -69,16 +72,18 @@ const DATABASE = createMockDatabase({
tables: [TABLE],
});
-const QUERY = createQuery({
+const METADATA = createMockMetadata({ databases: [DATABASE] });
+const PROVIDER = createMetadataProvider({
+ metadata: METADATA,
databaseId: DATABASE.id,
- metadata: createMockMetadata({ databases: [DATABASE] }),
- query: {
- database: DATABASE.id,
- type: "query",
- query: {
- "source-table": TABLE.id,
+});
+
+const QUERY = Lib.createTestQuery(PROVIDER, {
+ stages: [
+ {
+ source: { type: "table", id: TABLE.id },
},
- },
+ ],
});
function getColumn(name: string) {
diff --git a/frontend/src/metabase/query_builder/components/expressions/Editor/HelpText/HelpText.stories.tsx b/frontend/src/metabase/query_builder/components/expressions/Editor/HelpText/HelpText.stories.tsx
index 536195a2762..6ce2a11643f 100644
--- a/frontend/src/metabase/query_builder/components/expressions/Editor/HelpText/HelpText.stories.tsx
+++ b/frontend/src/metabase/query_builder/components/expressions/Editor/HelpText/HelpText.stories.tsx
@@ -2,7 +2,11 @@ import type { StoryFn } from "@storybook/react";
import { createMockMetadata } from "__support__/metadata";
import { ReduxProvider } from "__support__/storybook";
-import { createQuery } from "metabase-lib/test-helpers";
+import * as Lib from "metabase-lib";
+import {
+ DEFAULT_TEST_QUERY,
+ createMetadataProvider,
+} from "metabase-lib/test-helpers";
import { createMockDatabase } from "metabase-types/api/mocks";
import { HelpText } from "./HelpText";
@@ -15,9 +19,11 @@ export default {
const Template: StoryFn<typeof HelpText> = () => {
const database = createMockDatabase();
const metadata = createMockMetadata({ databases: [database] });
- const query = createQuery({
+ const provider = createMetadataProvider({
databaseId: database.id,
+ metadata,
});
+ const query = Lib.createTestQuery(provider, DEFAULT_TEST_QUERY);
return (
<ReduxProvider>
diff --git a/frontend/src/metabase/query_builder/components/expressions/Editor/HelpText/tests/setup.tsx b/frontend/src/metabase/query_builder/components/expressions/Editor/HelpText/tests/setup.tsx
index bef4ee51dd6..6e930096428 100644
--- a/frontend/src/metabase/query_builder/components/expressions/Editor/HelpText/tests/setup.tsx
+++ b/frontend/src/metabase/query_builder/components/expressions/Editor/HelpText/tests/setup.tsx
@@ -4,8 +4,11 @@ import { mockSettings } from "__support__/settings";
import { renderWithProviders } from "__support__/ui";
import { checkNotNull } from "metabase/lib/types";
import { getHelpText } from "metabase/querying/expressions";
-import type * as Lib from "metabase-lib";
-import { createQuery } from "metabase-lib/test-helpers";
+import * as Lib from "metabase-lib";
+import {
+ DEFAULT_TEST_QUERY,
+ createMetadataProvider,
+} from "metabase-lib/test-helpers";
import type { TokenFeatures } from "metabase-types/api";
import { createMockTokenFeatures } from "metabase-types/api/mocks";
import {
@@ -42,10 +45,12 @@ export async function setup({
});
const metadata = createMockMetadata({ databases: [createSampleDatabase()] });
- const database = checkNotNull(metadata.database(SAMPLE_DB_ID));
- const query = createQuery({
- databaseId: database.id,
+ const provider = createMetadataProvider({
+ databaseId: SAMPLE_DB_ID,
+ metadata,
});
+ const database = checkNotNull(metadata.database(SAMPLE_DB_ID));
+ const query = Lib.createTestQuery(provider, DEFAULT_TEST_QUERY);
const props: HelpTextProps = {
enclosingFunction: {
diff --git a/frontend/src/metabase/query_builder/components/expressions/ExpressionWidget/ExpressionWidget.unit.spec.tsx b/frontend/src/metabase/query_builder/components/expressions/ExpressionWidget/ExpressionWidget.unit.spec.tsx
index 9d0c6c00f06..a09970590fc 100644
--- a/frontend/src/metabase/query_builder/components/expressions/ExpressionWidget/ExpressionWidget.unit.spec.tsx
+++ b/frontend/src/metabase/query_builder/components/expressions/ExpressionWidget/ExpressionWidget.unit.spec.tsx
@@ -2,7 +2,7 @@ import userEvent from "@testing-library/user-event";
import { renderWithProviders, screen, waitFor } from "__support__/ui";
import * as Lib from "metabase-lib";
-import { createQuery } from "metabase-lib/test-helpers";
+import { DEFAULT_TEST_QUERY, SAMPLE_PROVIDER } from "metabase-lib/test-helpers";
import type { ExpressionWidgetProps } from "./ExpressionWidget";
import { ExpressionWidget } from "./ExpressionWidget";
@@ -164,7 +164,7 @@ describe("ExpressionWidget", () => {
});
async function setup(additionalProps?: Partial<ExpressionWidgetProps>) {
- const query = createQuery();
+ const query = Lib.createTestQuery(SAMPLE_PROVIDER, DEFAULT_TEST_QUERY);
const stageIndex = 0;
const availableColumns = Lib.expressionableColumns(query, stageIndex);
const onChangeClause = jest.fn();
diff --git a/frontend/src/metabase/query_builder/components/expressions/ExtractColumn/util.unit.spec.ts b/frontend/src/metabase/query_builder/components/expressions/ExtractColumn/util.unit.spec.ts
index 7509ec68d7a..fa114f3766a 100644
--- a/frontend/src/metabase/query_builder/components/expressions/ExtractColumn/util.unit.spec.ts
+++ b/frontend/src/metabase/query_builder/components/expressions/ExtractColumn/util.unit.spec.ts
@@ -1,6 +1,6 @@
import { createMockMetadata } from "__support__/metadata";
-import type * as Lib from "metabase-lib";
-import { createQuery } from "metabase-lib/test-helpers";
+import * as Lib from "metabase-lib";
+import { createMetadataProvider } from "metabase-lib/test-helpers";
import {
createMockDatabase,
createMockField,
@@ -25,16 +25,18 @@ const DATABASE = createMockDatabase({
tables: [TABLE],
});
-const QUERY = createQuery({
+const METADATA = createMockMetadata({ databases: [DATABASE] });
+const PROVIDER = createMetadataProvider({
databaseId: DATABASE.id,
- metadata: createMockMetadata({ databases: [DATABASE] }),
- query: {
- database: DATABASE.id,
- type: "query",
- query: {
- "source-table": TABLE.id,
+ metadata: METADATA,
+});
+
+const QUERY = Lib.createTestQuery(PROVIDER, {
+ stages: [
+ {
+ source: { type: "table", id: TABLE.id },
},
- },
+ ],
});
describe("getName", () => {
diff --git a/frontend/src/metabase/query_builder/components/view/ViewHeader/components/FilterHeaderButton.unit.spec.tsx b/frontend/src/metabase/query_builder/components/view/ViewHeader/components/FilterHeaderButton.unit.spec.tsx
index b3be8f1f179..f6ab5793afc 100644
--- a/frontend/src/metabase/query_builder/components/view/ViewHeader/components/FilterHeaderButton.unit.spec.tsx
+++ b/frontend/src/metabase/query_builder/components/view/ViewHeader/components/FilterHeaderButton.unit.spec.tsx
@@ -1,17 +1,45 @@
import { renderWithProviders, screen } from "__support__/ui";
import * as Lib from "metabase-lib";
-import { SAMPLE_METADATA, createQuery } from "metabase-lib/test-helpers";
+import {
+ DEFAULT_TEST_QUERY,
+ SAMPLE_METADATA,
+ SAMPLE_PROVIDER,
+} from "metabase-lib/test-helpers";
import Question from "metabase-lib/v1/Question";
+import { ORDERS_ID } from "metabase-types/api/mocks/presets";
import { FilterHeaderButton } from "./FilterHeaderButton";
+const queryWithFilters = Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
+ {
+ source: { type: "table", id: ORDERS_ID },
+ filters: [
+ {
+ type: "operator",
+ operator: ">",
+ args: [
+ { type: "literal", value: 1 },
+ { type: "literal", value: 2 },
+ ],
+ },
+ ],
+ },
+ ],
+});
+
const QUESTION_WITH_FILTERS = Question.create({
metadata: SAMPLE_METADATA,
-}).setQuery(Lib.filter(createQuery(), 0, Lib.expressionClause(">", [1, 2])));
+}).setQuery(queryWithFilters);
+
+const queryWithoutFilters = Lib.createTestQuery(
+ SAMPLE_PROVIDER,
+ DEFAULT_TEST_QUERY,
+);
const QUESTION_WITHOUT_FILTERS = Question.create({
metadata: SAMPLE_METADATA,
-}).setQuery(createQuery());
+}).setQuery(queryWithoutFilters);
type SetupOpts = {
question?: Question;
diff --git a/frontend/src/metabase/query_builder/components/view/ViewHeader/components/QuestionFiltersHeader/QuestionFiltersHeader.unit.spec.tsx b/frontend/src/metabase/query_builder/components/view/ViewHeader/components/QuestionFiltersHeader/QuestionFiltersHeader.unit.spec.tsx
index 7945bd69133..8b21525eab3 100644
--- a/frontend/src/metabase/query_builder/components/view/ViewHeader/components/QuestionFiltersHeader/QuestionFiltersHeader.unit.spec.tsx
+++ b/frontend/src/metabase/query_builder/components/view/ViewHeader/components/QuestionFiltersHeader/QuestionFiltersHeader.unit.spec.tsx
@@ -6,15 +6,12 @@ import { setupFieldValuesEndpoint } from "__support__/server-mocks";
import { renderWithProviders, screen, within } from "__support__/ui";
import { checkNotNull } from "metabase/lib/types";
import * as Lib from "metabase-lib";
-import { createQuery } from "metabase-lib/test-helpers";
+import { SAMPLE_PROVIDER } from "metabase-lib/test-helpers";
import Question from "metabase-lib/v1/Question";
import type { GetFieldValuesResponse } from "metabase-types/api";
import {
- ORDERS,
ORDERS_ID,
- PEOPLE,
PEOPLE_SOURCE_VALUES,
- SAMPLE_DB_ID,
createSampleDatabase,
} from "metabase-types/api/mocks/presets";
@@ -209,71 +206,47 @@ describe("QuestionFiltersHeader", () => {
* Stage 1: Count by User.Source, filtered by Count > 5
* Stage 2: Count by user.Source, filtered by User.Source = "Organic"
*/
-const TEST_MULTISTAGE_QUERY = createQuery({
- metadata,
- query: {
- type: "query",
- database: SAMPLE_DB_ID,
- query: {
- filter: [
- "=",
- [
- "field",
- "PEOPLE__via__USER_ID__SOURCE",
- {
- "base-type": "type/Text",
- },
- ],
- "Organic",
- ],
- "source-query": {
- aggregation: [["count"]],
- breakout: [
- [
- "field",
- "PEOPLE__via__USER_ID__SOURCE",
- {
- "base-type": "type/Text",
- },
- ],
- ],
- filter: [
- ">",
- [
- "field",
- "count",
- {
- "base-type": "type/Integer",
- },
+const TEST_MULTISTAGE_QUERY = Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
+ {
+ source: { type: "table", id: ORDERS_ID },
+ aggregations: [{ type: "operator", operator: "count" }],
+ filters: [
+ {
+ type: "operator",
+ operator: ">",
+ args: [
+ { type: "column", sourceName: "ORDERS", name: "QUANTITY" },
+ { type: "literal", value: 4 },
],
- 5,
- ],
- "source-query": {
- "source-table": ORDERS_ID,
- aggregation: [["count"]],
- breakout: [
- [
- "field",
- PEOPLE.SOURCE,
- {
- "base-type": "type/Text",
- "source-field": ORDERS.USER_ID,
- },
- ],
+ },
+ ],
+ breakouts: [{ type: "column", sourceName: "PEOPLE", name: "SOURCE" }],
+ },
+ {
+ breakouts: [{ type: "column", name: "SOURCE" }],
+ filters: [
+ {
+ type: "operator",
+ operator: ">",
+ args: [
+ { type: "column", name: "count" },
+ { type: "literal", value: 5 },
],
- filter: [
- ">",
- [
- "field",
- ORDERS.QUANTITY,
- {
- "base-type": "type/Integer",
- },
- ],
- 4,
+ },
+ ],
+ },
+ {
+ filters: [
+ {
+ type: "operator",
+ operator: "=",
+ args: [
+ { type: "column", name: "SOURCE" },
+ { type: "literal", value: "Organic" },
],
},
- },
+ ],
},
- },
+ ],
});
diff --git a/frontend/src/metabase/query_builder/components/view/ViewHeader/components/SavedQuestionLeftSide/ViewOnly.unit.spec.tsx b/frontend/src/metabase/query_builder/components/view/ViewHeader/components/SavedQuestionLeftSide/ViewOnly.unit.spec.tsx
index 825136ebd8a..9e89b61e7fe 100644
--- a/frontend/src/metabase/query_builder/components/view/ViewHeader/components/SavedQuestionLeftSide/ViewOnly.unit.spec.tsx
+++ b/frontend/src/metabase/query_builder/components/view/ViewHeader/components/SavedQuestionLeftSide/ViewOnly.unit.spec.tsx
@@ -2,10 +2,9 @@ import userEvent from "@testing-library/user-event";
import { createMockEntitiesState } from "__support__/store";
import { renderWithProviders, screen } from "__support__/ui";
-import { checkNotNull } from "metabase/lib/types";
import { getMetadata } from "metabase/selectors/metadata";
import * as Lib from "metabase-lib";
-import { createQuery } from "metabase-lib/test-helpers";
+import { DEFAULT_TEST_QUERY, SAMPLE_PROVIDER } from "metabase-lib/test-helpers";
import Question from "metabase-lib/v1/Question";
import type { Card, Database, Table } from "metabase-types/api";
import { createMockCard } from "metabase-types/api/mocks";
@@ -81,8 +80,7 @@ async function expectPopoverToHaveText(text: string) {
const HIDDEN_VISIBILITY_TYPES = ["hidden", "technical", "cruft"] as const;
const ORDERS_QUERY = (function () {
- const query = createQuery({ databaseId: SAMPLE_DB_ID });
-
+ const query = Lib.createTestQuery(SAMPLE_PROVIDER, DEFAULT_TEST_QUERY);
const availableColumns = Lib.fieldableColumns(query, -1);
const columns = availableColumns.filter((column) => {
const info = Lib.displayInfo(query, -1, column);
@@ -92,28 +90,26 @@ const ORDERS_QUERY = (function () {
return Lib.withFields(query, -1, columns);
})();
-const ORDERS_JOIN_PRODUCTS_QUERY = (function () {
- let query = createQuery({ databaseId: SAMPLE_DB_ID });
- const joinTable = checkNotNull(Lib.tableOrCardMetadata(query, PRODUCTS_ID));
-
- query = Lib.join(
- query,
- -1,
- Lib.joinClause(
- joinTable,
- [
- Lib.joinConditionClause(
- Lib.joinConditionOperators(query, -1)[0],
- Lib.joinConditionLHSColumns(query, -1)[0],
- Lib.joinConditionRHSColumns(query, -1, joinTable)[0],
- ),
+const ORDERS_JOIN_PRODUCTS_QUERY = Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
+ {
+ source: { type: "table", id: ORDERS_ID },
+ joins: [
+ {
+ source: { type: "table", id: PRODUCTS_ID },
+ strategy: "left-join",
+ conditions: [
+ {
+ operator: "=",
+ left: { type: "column", name: "ID", sourceName: "ORDERS" },
+ right: { type: "column", name: "ID", sourceName: "PRODUCTS" },
+ },
+ ],
+ },
],
- Lib.availableJoinStrategies(query, -1)[0],
- ),
- );
-
- return query;
-})();
+ },
+ ],
+});
function createCardFromQuery({
query,
@@ -130,14 +126,11 @@ describe("ViewOnlyTag", () => {
it("should show the View-only badge when the source card is inaccessible", async () => {
setup({
card: createCardFromQuery({
- query: createQuery({
- databaseId: SAMPLE_DB_ID,
+ query: Lib.fromJsQuery(SAMPLE_PROVIDER, {
+ database: SAMPLE_DB_ID,
+ type: "query",
query: {
- database: SAMPLE_DB_ID,
- type: "query",
- query: {
- "source-table": "card__123",
- },
+ "source-table": "card__123",
},
}),
}),
@@ -148,33 +141,29 @@ describe("ViewOnlyTag", () => {
});
it("should show the View-only badge when a joined card is inaccessible", async () => {
- setup({
- card: createCardFromQuery({
- query: createQuery({
- query: {
- type: "query",
- database: SAMPLE_DB_ID,
- query: {
- "source-table": ORDERS_ID,
- joins: [
- {
- alias: "Orders Question",
- fields: "all",
- // This card does not exist
- "source-table": "card__123",
- condition: [
- "=",
- ["field", PRODUCTS.ID, null],
- ["field", ORDERS.PRODUCT_ID, null],
- ],
- },
- ],
- },
+ const query = Lib.fromJsQuery(SAMPLE_PROVIDER, {
+ database: SAMPLE_DB_ID,
+ type: "query",
+ query: {
+ "source-table": ORDERS_ID,
+ joins: [
+ {
+ alias: "Orders Question",
+ fields: "all",
+ // This card does not exist
+ "source-table": "card__123",
+ condition: [
+ "=",
+ ["field", PRODUCTS.ID, null],
+ ["field", ORDERS.PRODUCT_ID, null],
+ ],
},
- }),
- }),
+ ],
+ },
});
+ setup({ card: createCardFromQuery({ query }) });
+
expect(screen.getByText("View-only")).toBeInTheDocument();
await expectNoPopover();
});
diff --git a/frontend/src/metabase/query_builder/components/view/sidebars/QuestionInfoSidebar/tests/common.unit.spec.tsx b/frontend/src/metabase/query_builder/components/view/sidebars/QuestionInfoSidebar/tests/common.unit.spec.tsx
index 8a689252638..b397966c776 100644
--- a/frontend/src/metabase/query_builder/components/view/sidebars/QuestionInfoSidebar/tests/common.unit.spec.tsx
+++ b/frontend/src/metabase/query_builder/components/view/sidebars/QuestionInfoSidebar/tests/common.unit.spec.tsx
@@ -4,7 +4,7 @@ import { testDataset } from "__support__/testDataset";
import { screen, within } from "__support__/ui";
import * as Urls from "metabase/lib/urls";
import * as Lib from "metabase-lib";
-import { createQuery, getJoinQueryHelpers } from "metabase-lib/test-helpers";
+import { SAMPLE_PROVIDER } from "metabase-lib/test-helpers";
import type { BaseEntityId } from "metabase-types/api";
import {
createMockCard,
@@ -12,7 +12,7 @@ import {
createMockModerationReview,
createMockUserInfo,
} from "metabase-types/api/mocks";
-import { PRODUCTS_ID } from "metabase-types/api/mocks/presets";
+import { ORDERS_ID, PRODUCTS_ID } from "metabase-types/api/mocks/presets";
import { setup } from "./setup";
@@ -278,25 +278,28 @@ describe("QuestionInfoSidebar", () => {
});
function getJoinedQuery() {
- const query = createQuery();
- const {
- table,
- defaultStrategy,
- defaultOperator,
- findLHSColumn,
- findRHSColumn,
- } = getJoinQueryHelpers(query, 0, PRODUCTS_ID);
- const ordersProductId = findLHSColumn("ORDERS", "PRODUCT_ID");
- const productsId = findRHSColumn("PRODUCTS", "ID");
- const stageIndex = -1;
- const condition = Lib.joinConditionClause(
- defaultOperator,
- ordersProductId,
- productsId,
- );
- return Lib.join(
- query,
- stageIndex,
- Lib.joinClause(table, [condition], defaultStrategy),
- );
+ return Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
+ {
+ source: { type: "table", id: ORDERS_ID },
+ joins: [
+ {
+ source: { type: "table", id: PRODUCTS_ID },
+ strategy: "left-join",
+ conditions: [
+ {
+ operator: "=",
+ left: {
+ type: "column",
+ sourceName: "ORDERS",
+ name: "PRODUCT_ID",
+ },
+ right: { type: "column", sourceName: "PRODUCTS", name: "ID" },
+ },
+ ],
+ },
+ ],
+ },
+ ],
+ });
}
diff --git a/frontend/src/metabase/query_builder/components/view/sidebars/SummarizeSidebar/SummarizeSidebar.unit.spec.tsx b/frontend/src/metabase/query_builder/components/view/sidebars/SummarizeSidebar/SummarizeSidebar.unit.spec.tsx
index bab6ea1ec82..ad37905c229 100644
--- a/frontend/src/metabase/query_builder/components/view/sidebars/SummarizeSidebar/SummarizeSidebar.unit.spec.tsx
+++ b/frontend/src/metabase/query_builder/components/view/sidebars/SummarizeSidebar/SummarizeSidebar.unit.spec.tsx
@@ -3,8 +3,9 @@ import { useState } from "react";
import { renderWithProviders, screen, waitFor, within } from "__support__/ui";
import * as Lib from "metabase-lib";
-import { createQuery, createQueryWithClauses } from "metabase-lib/test-helpers";
+import { DEFAULT_TEST_QUERY, SAMPLE_PROVIDER } from "metabase-lib/test-helpers";
import { createMockCard } from "metabase-types/api/mocks";
+import { ORDERS_ID } from "metabase-types/api/mocks/presets";
import {
createMockQueryBuilderState,
createMockState,
@@ -18,44 +19,65 @@ type SetupOpts = {
};
function createSummarizedQuery() {
- return createQueryWithClauses({
- aggregations: [
- { operatorName: "max", tableName: "ORDERS", columnName: "QUANTITY" },
- ],
- breakouts: [
- {
- tableName: "ORDERS",
- columnName: "CREATED_AT",
- temporalBucketName: "Month",
- },
+ return Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
{
- tableName: "PRODUCTS",
- columnName: "CATEGORY",
+ source: { type: "table", id: ORDERS_ID },
+ aggregations: [
+ {
+ type: "operator",
+ operator: "max",
+ args: [{ type: "column", name: "QUANTITY" }],
+ },
+ ],
+ breakouts: [
+ {
+ type: "column",
+ sourceName: "ORDERS",
+ name: "CREATED_AT",
+ unit: "month",
+ },
+ {
+ type: "column",
+ sourceName: "PRODUCTS",
+ name: "CATEGORY",
+ },
+ ],
},
],
});
}
function createQueryWithBreakoutsForSameColumn() {
- return createQueryWithClauses({
- aggregations: [{ operatorName: "count" }],
- breakouts: [
- {
- tableName: "ORDERS",
- columnName: "CREATED_AT",
- temporalBucketName: "Year",
- },
+ return Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
{
- tableName: "ORDERS",
- columnName: "CREATED_AT",
- temporalBucketName: "Quarter",
+ source: { type: "table", id: ORDERS_ID },
+ aggregations: [{ type: "operator", operator: "count", args: [] }],
+ breakouts: [
+ {
+ type: "column",
+ sourceName: "ORDERS",
+ name: "CREATED_AT",
+ unit: "year",
+ },
+ {
+ type: "column",
+ sourceName: "ORDERS",
+ name: "CREATED_AT",
+ unit: "quarter",
+ },
+ ],
},
],
});
}
async function setup({
- query: initialQuery = createQuery(),
+ query: initialQuery = Lib.createTestQuery(
+ SAMPLE_PROVIDER,
+ DEFAULT_TEST_QUERY,
+ ),
withDefaultAggregation = true,
}: SetupOpts = {}) {
const onQueryChange = jest.fn();
@@ -144,8 +166,13 @@ describe("SummarizeSidebar", () => {
it("should allow to remove last not default aggregation (metabase#48033)", async () => {
await setup({
- query: createQueryWithClauses({
- aggregations: [{ operatorName: "count" }],
+ query: Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
+ {
+ source: { type: "table", id: ORDERS_ID },
+ aggregations: [{ type: "operator", operator: "count", args: [] }],
+ },
+ ],
}),
});
@@ -177,7 +204,7 @@ describe("SummarizeSidebar", () => {
});
it("should list breakoutable columns", async () => {
- const query = createQuery();
+ const query = Lib.createTestQuery(SAMPLE_PROVIDER, DEFAULT_TEST_QUERY);
const columns = Lib.breakoutableColumns(query, -1);
await setup({ query });
diff --git a/frontend/src/metabase/querying/expressions/formatter/formatter.unit.spec.ts b/frontend/src/metabase/querying/expressions/formatter/formatter.unit.spec.ts
index 0683ed91ff5..3e7affa7208 100644
--- a/frontend/src/metabase/querying/expressions/formatter/formatter.unit.spec.ts
+++ b/frontend/src/metabase/querying/expressions/formatter/formatter.unit.spec.ts
@@ -3,8 +3,13 @@ import expression from "ts-dedent";
import { createMockMetadata } from "__support__/metadata";
import * as Lib from "metabase-lib";
-import { createQuery } from "metabase-lib/test-helpers";
+import {
+ SAMPLE_PROVIDER,
+ createMetadataProvider,
+} from "metabase-lib/test-helpers";
+import { ORDERS_ID } from "metabase-types/api/mocks/presets";
+import { SAMPLE_DB_ID } from "../../../../../../e2e/support/cypress_data";
import { compileExpression } from "../compile-expression";
import {
expressions,
@@ -276,12 +281,20 @@ describe("format", () => {
});
describe("formats unknown references", () => {
- const otherQuery = createQuery({
- metadata: createMockMetadata({
- databases: [
- // no database so metadata cannot reference anything
- ],
- }),
+ const metadata = createMockMetadata({
+ databases: [
+ // no database so metadata cannot reference anything
+ ],
+ });
+
+ const provider = createMetadataProvider({ metadata });
+
+ const otherQuery = Lib.fromJsQuery(provider, {
+ database: SAMPLE_DB_ID,
+ type: "query",
+ query: {
+ "source-table": ORDERS_ID,
+ },
});
it.each([
@@ -703,43 +716,41 @@ it("should format escaped regex characters (metabase#56596)", async () => {
// TODO: unskip when we have a fix for metabase#58371
// eslint-disable-next-line jest/no-disabled-tests
it.skip("should format joined columns properly (metabase#58371)", async () => {
- const query = createQuery({
+ const query = Lib.fromJsQuery(SAMPLE_PROVIDER, {
+ database: SAMPLE_DB_ID,
+ type: "query",
query: {
- database: 1,
- type: "query",
- query: {
- joins: [
- {
- alias: "Other Table",
- condition: [
- "=",
- [
- "field",
- "field_a",
- {
- "base-type": "type/Number",
- },
- ],
- [
- "field",
- "field_b",
- {
- "base-type": "type/Number",
- },
- ],
+ joins: [
+ {
+ alias: "Other Table",
+ condition: [
+ "=",
+ [
+ "field",
+ "field_a",
+ {
+ "base-type": "type/Number",
+ },
+ ],
+ [
+ "field",
+ "field_b",
+ {
+ "base-type": "type/Number",
+ },
],
- },
- ],
- expressions: {
- foo: [
- "field",
- "Fieldname that has a non-removable dash",
- {
- "base-type": "type/Integer",
- "join-alias": "Other Table",
- },
],
},
+ ],
+ expressions: {
+ foo: [
+ "field",
+ "Fieldname that has a non-removable dash",
+ {
+ "base-type": "type/Integer",
+ "join-alias": "Other Table",
+ },
+ ],
},
},
});
@@ -750,7 +761,5 @@ it.skip("should format joined columns properly (metabase#58371)", async () => {
stageIndex: -1,
});
- expect(formatted).toBe(
- "[Other Table → Fieldname that has a non-removable dash]",
- );
+ expect(formatted).toBe("[Fieldname That Has A Non Removable Dash]");
});
diff --git a/frontend/src/metabase/querying/expressions/suggestions/aggregations.unit.spec.ts b/frontend/src/metabase/querying/expressions/suggestions/aggregations.unit.spec.ts
index a70729d1b75..aa803934b06 100644
--- a/frontend/src/metabase/querying/expressions/suggestions/aggregations.unit.spec.ts
+++ b/frontend/src/metabase/querying/expressions/suggestions/aggregations.unit.spec.ts
@@ -1,5 +1,9 @@
import { createMockMetadata } from "__support__/metadata";
-import { createQuery } from "metabase-lib/test-helpers";
+import * as Lib from "metabase-lib";
+import {
+ DEFAULT_TEST_QUERY,
+ createMetadataProvider,
+} from "metabase-lib/test-helpers";
import type { DatabaseFeature } from "metabase-types/api";
import { createSampleDatabase } from "metabase-types/api/mocks/presets";
@@ -20,7 +24,8 @@ describe("suggestAggregations", () => {
}),
],
});
- const query = createQuery({ metadata });
+ const provider = createMetadataProvider({ metadata });
+ const query = Lib.createTestQuery(provider, DEFAULT_TEST_QUERY);
const source = suggestAggregations({
expressionMode,
query,
diff --git a/frontend/src/metabase/querying/expressions/suggestions/fields.unit.spec.ts b/frontend/src/metabase/querying/expressions/suggestions/fields.unit.spec.ts
index 147d73de67b..927a6f4793d 100644
--- a/frontend/src/metabase/querying/expressions/suggestions/fields.unit.spec.ts
+++ b/frontend/src/metabase/querying/expressions/suggestions/fields.unit.spec.ts
@@ -1,21 +1,19 @@
import { createMockMetadata } from "__support__/metadata";
import * as Lib from "metabase-lib";
-import { SAMPLE_DATABASE, createQuery } from "metabase-lib/test-helpers";
-import type { DatasetQuery, Join } from "metabase-types/api";
+import {
+ DEFAULT_TEST_QUERY,
+ SAMPLE_PROVIDER,
+ createMetadataProvider,
+} from "metabase-lib/test-helpers";
import {
createMockDatabase,
createMockField,
createMockTable,
} from "metabase-types/api/mocks";
-import {
- ORDERS,
- ORDERS_ID,
- REVIEWS,
- REVIEWS_ID,
-} from "metabase-types/api/mocks/presets";
+import { ORDERS_ID, REVIEWS_ID } from "metabase-types/api/mocks/presets";
import { columnsForExpressionMode } from "../mode";
-import { queryWithAggregation, sharedMetadata } from "../test/shared";
+import { queryWithAggregation, sharedProvider } from "../test/shared";
import { complete } from "./__support__";
import { suggestFields } from "./fields";
@@ -52,17 +50,16 @@ describe("suggestFields", () => {
tables: [TABLE],
});
- const query = createQuery({
+ const metadata = createMockMetadata({ databases: [DATABASE] });
+ const provider = createMetadataProvider({
databaseId: DATABASE.id,
- metadata: createMockMetadata({ databases: [DATABASE] }),
- query: {
- database: DATABASE.id,
- type: "query",
- query: {
- "source-table": TABLE.id,
- },
- },
+ metadata,
});
+
+ const query = Lib.createTestQuery(provider, {
+ stages: [{ source: { type: "table", id: TABLE.id } }],
+ });
+
const stageIndex = 0;
const expressionIndex = 0;
const source = suggestFields({
@@ -182,7 +179,7 @@ describe("suggestFields", () => {
});
it("should suggest foreign fields", () => {
- const query = createQuery();
+ const query = Lib.createTestQuery(SAMPLE_PROVIDER, DEFAULT_TEST_QUERY);
const stageIndex = -1;
const source = suggestFields({
query,
@@ -317,28 +314,33 @@ describe("suggestFields", () => {
});
it("should suggest joined fields", async () => {
- const JOIN_CLAUSE: Join = {
- alias: "Foo",
- ident: "pbHOWTxjodLToOUnFJe_k",
- "source-table": REVIEWS_ID,
- condition: [
- "=",
- ["field", REVIEWS.PRODUCT_ID, null],
- ["field", ORDERS.PRODUCT_ID, null],
+ const query = Lib.createTestQuery(sharedProvider, {
+ stages: [
+ {
+ source: { type: "table", id: ORDERS_ID },
+ joins: [
+ {
+ source: { type: "table", id: REVIEWS_ID },
+ strategy: "left-join",
+ conditions: [
+ {
+ operator: "=",
+ left: {
+ type: "column",
+ sourceName: "ORDERS",
+ name: "PRODUCT_ID",
+ },
+ right: {
+ type: "column",
+ sourceName: "REVIEWS",
+ name: "PRODUCT_ID",
+ },
+ },
+ ],
+ },
+ ],
+ },
],
- };
- const queryWithJoins: DatasetQuery = {
- database: SAMPLE_DATABASE.id,
- type: "query",
- query: {
- "source-table": ORDERS_ID,
- joins: [JOIN_CLAUSE],
- },
- };
-
- const query = createQuery({
- metadata: sharedMetadata,
- query: queryWithJoins,
});
const stageIndex = -1;
const source = suggestFields({
@@ -351,48 +353,58 @@ describe("suggestFields", () => {
}),
});
- complete(source, "Foo|");
-
- const result = await complete(source, "Foo|");
+ const result = await complete(source, "Body|");
expect(result).toEqual({
from: 0,
- to: 3,
+ to: 4,
options: expect.any(Array),
});
expect(result?.options[0]).toEqual({
- displayLabel: "Foo → Body",
- label: "[Foo → Body]",
+ displayLabel: "Reviews - Product → Body",
+ label: "[Reviews - Product → Body]",
type: "field",
icon: "string",
column: expect.any(Object),
- matches: [[0, 2]],
+ matches: [
+ [12, 13],
+ [20, 23],
+ ],
});
expect(result?.options[1]).toEqual({
- displayLabel: "Foo → ID",
- label: "[Foo → ID]",
+ displayLabel: "Product ID",
+ label: "[Product ID]",
type: "field",
- icon: "label",
+ icon: "connections",
column: expect.any(Object),
- matches: [[0, 2]],
+ matches: [
+ [2, 3],
+ [9, 9],
+ ],
});
});
it("should suggest nested query fields", () => {
- const datasetQuery: DatasetQuery = {
- database: SAMPLE_DATABASE.id,
- type: "query",
- query: {
- "source-table": ORDERS_ID,
- aggregation: [["count"]],
- breakout: [["field", ORDERS.TOTAL, null]],
- },
- };
-
- const queryWithAggregation = createQuery({
- metadata: sharedMetadata,
- query: datasetQuery,
+ const queryWithAggregation = Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
+ {
+ source: { type: "table", id: ORDERS_ID },
+ aggregations: [
+ {
+ type: "operator",
+ operator: "count",
+ },
+ ],
+ breakouts: [
+ {
+ type: "column",
+ sourceName: "ORDERS",
+ name: "TOTAL",
+ },
+ ],
+ },
+ ],
});
const query = Lib.appendStage(queryWithAggregation);
diff --git a/frontend/src/metabase/querying/expressions/suggestions/functions.unit.spec.ts b/frontend/src/metabase/querying/expressions/suggestions/functions.unit.spec.ts
index 9705fdbae96..ea94322a615 100644
--- a/frontend/src/metabase/querying/expressions/suggestions/functions.unit.spec.ts
+++ b/frontend/src/metabase/querying/expressions/suggestions/functions.unit.spec.ts
@@ -1,5 +1,9 @@
import { createMockMetadata } from "__support__/metadata";
-import { createQuery } from "metabase-lib/test-helpers";
+import * as Lib from "metabase-lib";
+import {
+ DEFAULT_TEST_QUERY,
+ createMetadataProvider,
+} from "metabase-lib/test-helpers";
import type { DatabaseFeature } from "metabase-types/api";
import { createSampleDatabase } from "metabase-types/api/mocks/presets";
@@ -20,7 +24,8 @@ describe("suggestFunctions", () => {
}),
],
});
- const query = createQuery({ metadata });
+ const provider = createMetadataProvider({ metadata });
+ const query = Lib.createTestQuery(provider, DEFAULT_TEST_QUERY);
const source = suggestFunctions({
expressionMode,
query,
diff --git a/frontend/src/metabase/querying/expressions/suggestions/metrics.unit.spec.ts b/frontend/src/metabase/querying/expressions/suggestions/metrics.unit.spec.ts
index cbc6d794e9f..a777a913b33 100644
--- a/frontend/src/metabase/querying/expressions/suggestions/metrics.unit.spec.ts
+++ b/frontend/src/metabase/querying/expressions/suggestions/metrics.unit.spec.ts
@@ -1,5 +1,9 @@
import { createMockMetadata } from "__support__/metadata";
-import { SAMPLE_DATABASE, createQuery } from "metabase-lib/test-helpers";
+import * as Lib from "metabase-lib";
+import {
+ SAMPLE_DATABASE,
+ createMetadataProvider,
+} from "metabase-lib/test-helpers";
import {
createMockCard,
createMockField,
@@ -79,15 +83,17 @@ describe("suggestMetrics", () => {
questions: [METRIC_FOO],
});
- const query = createQuery({
+ const provider = createMetadataProvider({
metadata,
- query: {
- database: DATABASE.id,
- type: "query",
- query: {
- "source-table": TABLE.id,
+ databaseId: DATABASE.id,
+ });
+
+ const query = Lib.createTestQuery(provider, {
+ stages: [
+ {
+ source: { type: "table", id: TABLE.id },
},
- },
+ ],
});
const source = suggestMetrics({
diff --git a/frontend/src/metabase/querying/expressions/suggestions/segments.unit.spec.ts b/frontend/src/metabase/querying/expressions/suggestions/segments.unit.spec.ts
index a92224ce4de..7055cb418da 100644
--- a/frontend/src/metabase/querying/expressions/suggestions/segments.unit.spec.ts
+++ b/frontend/src/metabase/querying/expressions/suggestions/segments.unit.spec.ts
@@ -1,5 +1,9 @@
import { createMockMetadata } from "__support__/metadata";
-import { SAMPLE_DATABASE, createQuery } from "metabase-lib/test-helpers";
+import * as Lib from "metabase-lib";
+import {
+ SAMPLE_DATABASE,
+ createMetadataProvider,
+} from "metabase-lib/test-helpers";
import { createMockSegment, createMockTable } from "metabase-types/api/mocks";
import { createSampleDatabase } from "metabase-types/api/mocks/presets";
@@ -41,15 +45,20 @@ describe("suggestSegments", () => {
segments: [SEGMENT_FOO, SEGMENT_BAR],
});
- const query = createQuery({
+ const provider = createMetadataProvider({
metadata,
- query: {
- database: DATABASE.id,
- type: "query",
- query: {
- "source-table": TABLE.id,
+ databaseId: DATABASE.id,
+ });
+
+ const query = Lib.createTestQuery(provider, {
+ stages: [
+ {
+ source: {
+ type: "table",
+ id: TABLE.id,
+ },
},
- },
+ ],
});
const source = suggestSegments({
diff --git a/frontend/src/metabase/querying/expressions/test/shared.ts b/frontend/src/metabase/querying/expressions/test/shared.ts
index ae3709fba60..ebd77206f04 100644
--- a/frontend/src/metabase/querying/expressions/test/shared.ts
+++ b/frontend/src/metabase/querying/expressions/test/shared.ts
@@ -1,11 +1,7 @@
import { createMockMetadata } from "__support__/metadata";
import { getNextId } from "__support__/utils";
import * as Lib from "metabase-lib";
-import {
- type ExpressionClauseOpts,
- createQuery,
- createQueryWithClauses,
-} from "metabase-lib/test-helpers";
+import { createMetadataProvider } from "metabase-lib/test-helpers";
import {
COMMON_DATABASE_FEATURES,
createMockCard,
@@ -110,78 +106,197 @@ metadata = createMockMetadata({
],
});
-const exprs: ExpressionClauseOpts[] = [
- {
- name: "foo",
- operator: "+",
- args: [1, 2],
- },
- {
- name: "bool",
- operator: "=",
- args: [1, 1],
- },
- {
- name: "name with [brackets]",
- operator: "+",
- args: [1, 2],
- },
+export const query = Lib.createTestQuery(
+ createMetadataProvider({ databaseId: SAMPLE_DB_ID, metadata }),
{
- name: "name with \\ slash",
- operator: "+",
- args: [1, 2],
- },
- {
- name: "stringly",
- operator: "concat",
- args: ["foo", "bar"],
- },
- {
- name: "bar",
- operator: "+",
- args: [1, 2],
- },
- {
- name: "BAR",
- operator: "+",
- args: [1, 2],
- },
-];
-
-export const query = createQueryWithClauses({
- query: createQuery({
- metadata,
- query: createMockStructuredDatasetQuery({
- database: SAMPLE_DB_ID,
- query: createMockStructuredQuery({
- "source-table": ORDERS_ID,
+ stages: [
+ {
+ source: { type: "table", id: ORDERS_ID },
fields: [],
- }),
- }),
- }),
- expressions: exprs,
-});
+ expressions: [
+ {
+ name: "foo",
+ value: {
+ type: "operator",
+ operator: "+",
+ args: [
+ { type: "literal", value: 1 },
+ { type: "literal", value: 2 },
+ ],
+ },
+ },
+ {
+ name: "bool",
+ value: {
+ type: "operator",
+ operator: "=",
+ args: [
+ { type: "literal", value: 1 },
+ { type: "literal", value: 1 },
+ ],
+ },
+ },
+ {
+ name: "name with [brackets]",
+ value: {
+ type: "operator",
+ operator: "+",
+ args: [
+ { type: "literal", value: 1 },
+ { type: "literal", value: 2 },
+ ],
+ },
+ },
+ {
+ name: "name with \\ slash",
+ value: {
+ type: "operator",
+ operator: "+",
+ args: [
+ { type: "literal", value: 1 },
+ { type: "literal", value: 2 },
+ ],
+ },
+ },
+ {
+ name: "stringly",
+ value: {
+ type: "operator",
+ operator: "concat",
+ args: [
+ { type: "literal", value: "foo" },
+ { type: "literal", value: "bar" },
+ ],
+ },
+ },
+ {
+ name: "bar",
+ value: {
+ type: "operator",
+ operator: "+",
+ args: [
+ { type: "literal", value: 1 },
+ { type: "literal", value: 2 },
+ ],
+ },
+ },
+ {
+ name: "BAR",
+ value: {
+ type: "operator",
+ operator: "+",
+ args: [
+ { type: "literal", value: 1 },
+ { type: "literal", value: 2 },
+ ],
+ },
+ },
+ ],
+ },
+ ],
+ },
+);
-export const queryWithAggregation = createQueryWithClauses({
- query: createQuery({
- metadata,
- query: createMockStructuredDatasetQuery({
- database: SAMPLE_DB_ID,
- query: createMockStructuredQuery({
- "source-table": ORDERS_ID,
+export const queryWithAggregation = Lib.createTestQuery(
+ createMetadataProvider({ databaseId: SAMPLE_DB_ID, metadata }),
+ {
+ stages: [
+ {
+ source: { type: "table", id: ORDERS_ID },
fields: [],
- aggregation: [
- [
- "aggregation-options",
- ["sum", ["field", ORDERS.TOTAL, null]],
- { name: "Bar Aggregation", "display-name": "Bar Aggregation" },
- ],
+ aggregations: [
+ {
+ name: "Bar Aggregation",
+ value: {
+ type: "operator",
+ operator: "sum",
+ args: [{ type: "column", name: "TOTAL" }],
+ },
+ },
],
- }),
- }),
- }),
- expressions: exprs,
-});
+ expressions: [
+ {
+ name: "foo",
+ value: {
+ type: "operator",
+ operator: "+",
+ args: [
+ { type: "literal", value: 1 },
+ { type: "literal", value: 2 },
+ ],
+ },
+ },
+ {
+ name: "bool",
+ value: {
+ type: "operator",
+ operator: "=",
+ args: [
+ { type: "literal", value: 1 },
+ { type: "literal", value: 1 },
+ ],
+ },
+ },
+ {
+ name: "name with [brackets]",
+ value: {
+ type: "operator",
+ operator: "+",
+ args: [
+ { type: "literal", value: 1 },
+ { type: "literal", value: 2 },
+ ],
+ },
+ },
+ {
+ name: "name with \\ slash",
+ value: {
+ type: "operator",
+ operator: "+",
+ args: [
+ { type: "literal", value: 1 },
+ { type: "literal", value: 2 },
+ ],
+ },
+ },
+ {
+ name: "stringly",
+ value: {
+ type: "operator",
+ operator: "concat",
+ args: [
+ { type: "literal", value: "foo" },
+ { type: "literal", value: "bar" },
+ ],
+ },
+ },
+ {
+ name: "bar",
+ value: {
+ type: "operator",
+ operator: "+",
+ args: [
+ { type: "literal", value: 1 },
+ { type: "literal", value: 2 },
+ ],
+ },
+ },
+ {
+ name: "BAR",
+ value: {
+ type: "operator",
+ operator: "+",
+ args: [
+ { type: "literal", value: 1 },
+ { type: "literal", value: 2 },
+ ],
+ },
+ },
+ ],
+ },
+ ],
+ },
+);
export const stageIndex = -1;
@@ -305,3 +420,7 @@ export const { fields, expressions, segments, metrics, measures } =
findDimensions(query);
export const sharedMetadata = metadata;
+export const sharedProvider = createMetadataProvider({
+ databaseId: database.id,
+ metadata,
+});
diff --git a/frontend/src/metabase/querying/fields/components/FieldPanel/FieldPanel.unit.spec.tsx b/frontend/src/metabase/querying/fields/components/FieldPanel/FieldPanel.unit.spec.tsx
index 081805a6076..50137144bfc 100644
--- a/frontend/src/metabase/querying/fields/components/FieldPanel/FieldPanel.unit.spec.tsx
+++ b/frontend/src/metabase/querying/fields/components/FieldPanel/FieldPanel.unit.spec.tsx
@@ -3,12 +3,8 @@ import { useState } from "react";
import { renderWithProviders, screen } from "__support__/ui";
import * as Lib from "metabase-lib";
-import {
- columnFinder,
- createQuery,
- createQueryWithClauses,
-} from "metabase-lib/test-helpers";
-import { PRODUCTS_ID } from "metabase-types/api/mocks/presets";
+import { DEFAULT_TEST_QUERY, SAMPLE_PROVIDER } from "metabase-lib/test-helpers";
+import { ORDERS_ID, PRODUCTS_ID } from "metabase-types/api/mocks/presets";
import { FieldPanel } from "./FieldPanel";
@@ -30,7 +26,10 @@ type SetupOpts = {
stageIndex?: number;
};
-function setup({ query = createQuery(), stageIndex = -1 }: SetupOpts = {}) {
+function setup({
+ query = Lib.createTestQuery(SAMPLE_PROVIDER, DEFAULT_TEST_QUERY),
+ stageIndex = -1,
+}: SetupOpts = {}) {
renderWithProviders(<Test query={query} stageIndex={stageIndex} />);
}
@@ -120,7 +119,11 @@ describe("QueryColumnPicker", () => {
});
it("should not allow to remove the last column from the data source via group", async () => {
- setup({ query: Lib.withDifferentTable(createQuery(), PRODUCTS_ID) });
+ const query = Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [{ source: { type: "table", id: PRODUCTS_ID } }],
+ });
+ setup({ query });
+
const [orderGroup, firstColumn, ...otherColumns] =
screen.getAllByRole("checkbox");
expect(orderGroup).toBeChecked();
@@ -147,11 +150,28 @@ describe("QueryColumnPicker", () => {
it("should not allow to remove fields for aggregated queries", async () => {
setup({
- query: createQueryWithClauses({
- query: createQuery(),
- aggregations: [
- { operatorName: "count" },
- { operatorName: "sum", columnName: "PRICE", tableName: "PRODUCTS" },
+ query: Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
+ {
+ source: {
+ type: "table",
+ id: ORDERS_ID,
+ },
+ aggregations: [
+ { type: "operator", operator: "count", args: [] },
+ {
+ type: "operator",
+ operator: "sum",
+ args: [
+ {
+ type: "column",
+ name: "PRICE",
+ sourceName: "PRODUCTS",
+ },
+ ],
+ },
+ ],
+ },
],
}),
});
@@ -167,9 +187,22 @@ describe("QueryColumnPicker", () => {
it("should not allow to remove fields for breakout queries", async () => {
setup({
- query: createQueryWithClauses({
- query: createQuery(),
- breakouts: [{ tableName: "PRODUCTS", columnName: "PRICE" }],
+ query: Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
+ {
+ source: {
+ type: "table",
+ id: ORDERS_ID,
+ },
+ breakouts: [
+ {
+ type: "column",
+ name: "PRICE",
+ sourceName: "PRODUCTS",
+ },
+ ],
+ },
+ ],
}),
});
@@ -183,27 +216,39 @@ describe("QueryColumnPicker", () => {
});
it("should not allow to remove the only field from multi-stage queries", () => {
- const initialQuery = Lib.appendStage(
- createQueryWithClauses({
- query: createQuery(),
- breakouts: [{ tableName: "PRODUCTS", columnName: "PRICE" }],
- }),
- );
- const stageIndex = 1;
- const findColumn = columnFinder(
- initialQuery,
- Lib.fieldableColumns(initialQuery, stageIndex),
- );
setup({
- query: Lib.filter(
- initialQuery,
- stageIndex,
- Lib.numberFilterClause({
- operator: "=",
- column: findColumn("PRODUCTS", "PRICE"),
- values: [1],
- }),
- ),
+ query: Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
+ {
+ source: {
+ type: "table",
+ id: ORDERS_ID,
+ },
+ breakouts: [
+ {
+ type: "column",
+ name: "PRICE",
+ sourceName: "PRODUCTS",
+ },
+ ],
+ },
+ {
+ filters: [
+ {
+ type: "operator",
+ operator: "=",
+ args: [
+ {
+ type: "column",
+ name: "PRICE",
+ },
+ { type: "literal", value: 1 },
+ ],
+ },
+ ],
+ },
+ ],
+ }),
});
const [group, ...columns] = screen.getAllByRole("checkbox");
@@ -217,30 +262,44 @@ describe("QueryColumnPicker", () => {
});
it("should allow to remove some but not all fields from multi-stage queries", async () => {
- const initialQuery = Lib.appendStage(
- createQueryWithClauses({
- query: createQuery(),
- breakouts: [
- { tableName: "PRODUCTS", columnName: "PRICE" },
- { tableName: "PRODUCTS", columnName: "CREATED_AT" },
+ setup({
+ query: Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
+ {
+ source: {
+ type: "table",
+ id: ORDERS_ID,
+ },
+ breakouts: [
+ {
+ type: "column",
+ name: "PRICE",
+ sourceName: "PRODUCTS",
+ },
+ {
+ type: "column",
+ name: "CREATED_AT",
+ sourceName: "PRODUCTS",
+ },
+ ],
+ },
+ {
+ filters: [
+ {
+ type: "operator",
+ operator: "=",
+ args: [
+ {
+ type: "column",
+ name: "PRICE",
+ },
+ { type: "literal", value: 1 },
+ ],
+ },
+ ],
+ },
],
}),
- );
- const stageIndex = 1;
- const findColumn = columnFinder(
- initialQuery,
- Lib.fieldableColumns(initialQuery, stageIndex),
- );
- setup({
- query: Lib.filter(
- initialQuery,
- stageIndex,
- Lib.numberFilterClause({
- operator: "=",
- column: findColumn("PRODUCTS", "PRICE"),
- values: [1],
- }),
- ),
});
const [group, firstColumn, secondColumn] = screen.getAllByRole("checkbox");
@@ -303,12 +362,26 @@ describe("QueryColumnPicker", () => {
});
it("should not allow to remove custom columns", async () => {
- const query = Lib.expression(
- createQuery(),
- -1,
- "Custom",
- Lib.expressionClause("+", [1, 2]),
- );
+ const query = Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
+ {
+ source: { type: "table", id: ORDERS_ID },
+ expressions: [
+ {
+ name: "Custom",
+ value: {
+ type: "operator",
+ operator: "+",
+ args: [
+ { type: "literal", value: 1 },
+ { type: "literal", value: 2 },
+ ],
+ },
+ },
+ ],
+ },
+ ],
+ });
setup({ query });
const [orderGroup, firstColumn] = screen.getAllByRole("checkbox");
const customColumn = screen.getByRole("checkbox", { name: "Custom" });
@@ -329,20 +402,52 @@ describe("QueryColumnPicker", () => {
});
it("should not allow to remove columns when there are expressions and only one removable column in multi-stage queries", () => {
- const initialQuery = Lib.appendStage(
- createQueryWithClauses({
- query: createQuery(),
- breakouts: [{ tableName: "PRODUCTS", columnName: "PRICE" }],
- }),
- );
- const stageIndex = 1;
setup({
- query: Lib.expression(
- initialQuery,
- stageIndex,
- "Custom",
- Lib.expressionClause("+", [1, 2]),
- ),
+ query: Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
+ {
+ source: {
+ type: "table",
+ id: ORDERS_ID,
+ },
+ breakouts: [
+ {
+ type: "column",
+ name: "PRICE",
+ sourceName: "PRODUCTS",
+ },
+ ],
+ },
+ {
+ expressions: [
+ {
+ name: "Custom",
+ value: {
+ type: "operator",
+ operator: "+",
+ args: [
+ { type: "literal", value: 1 },
+ { type: "literal", value: 2 },
+ ],
+ },
+ },
+ ],
+ filters: [
+ {
+ type: "operator",
+ operator: "=",
+ args: [
+ {
+ type: "column",
+ name: "PRICE",
+ },
+ { type: "literal", value: 1 },
+ ],
+ },
+ ],
+ },
+ ],
+ }),
});
const [group, ...columns] = screen.getAllByRole("checkbox");
diff --git a/frontend/src/metabase/querying/filters/components/FilterPanel/utils.unit.spec.ts b/frontend/src/metabase/querying/filters/components/FilterPanel/utils.unit.spec.ts
index 7b590987f76..e6c96389bbb 100644
--- a/frontend/src/metabase/querying/filters/components/FilterPanel/utils.unit.spec.ts
+++ b/frontend/src/metabase/querying/filters/components/FilterPanel/utils.unit.spec.ts
@@ -1,5 +1,5 @@
import * as Lib from "metabase-lib";
-import { createQuery } from "metabase-lib/test-helpers";
+import { DEFAULT_TEST_QUERY, SAMPLE_PROVIDER } from "metabase-lib/test-helpers";
import { getFilterItems } from "./utils";
@@ -13,7 +13,7 @@ function createMultiStageFilteredQuery() {
const stageIndexes = Array.from({ length: STAGE_COUNT }, (_, i) => i);
return stageIndexes.reduce(
(query) => Lib.appendStage(createFilteredQuery(query)),
- createQuery(),
+ Lib.createTestQuery(SAMPLE_PROVIDER, DEFAULT_TEST_QUERY),
);
}
diff --git a/frontend/src/metabase/querying/filters/components/FilterPicker/FilterColumnPicker/FilterColumnPicker.unit.spec.tsx b/frontend/src/metabase/querying/filters/components/FilterPicker/FilterColumnPicker/FilterColumnPicker.unit.spec.tsx
index 336a38a0369..6f8c1bb1387 100644
--- a/frontend/src/metabase/querying/filters/components/FilterPicker/FilterColumnPicker/FilterColumnPicker.unit.spec.tsx
+++ b/frontend/src/metabase/querying/filters/components/FilterPicker/FilterColumnPicker/FilterColumnPicker.unit.spec.tsx
@@ -1,7 +1,7 @@
import { setupFieldsValuesEndpoints } from "__support__/server-mocks";
import { fireEvent, renderWithProviders, screen } from "__support__/ui";
-import type * as Lib from "metabase-lib";
-import { createQuery } from "metabase-lib/test-helpers";
+import * as Lib from "metabase-lib";
+import { DEFAULT_TEST_QUERY, SAMPLE_PROVIDER } from "metabase-lib/test-helpers";
import { SAMPLE_DB_FIELD_VALUES } from "metabase-types/api/mocks/presets";
import { FilterColumnPicker } from "./FilterColumnPicker";
@@ -27,7 +27,7 @@ function setup({ query, stageIndexes }: SetupOpts) {
describe("FilterColumnPicker", () => {
test("The info icon should exist on each column", () => {
- const query = createQuery();
+ const query = Lib.createTestQuery(SAMPLE_PROVIDER, DEFAULT_TEST_QUERY);
const stageIndexes = [0];
setup({ query, stageIndexes });
expect(screen.getAllByLabelText("More info").length).toBeGreaterThanOrEqual(
@@ -36,7 +36,7 @@ describe("FilterColumnPicker", () => {
});
test("Searching by displayName should works (#39622)", () => {
- const query = createQuery();
+ const query = Lib.createTestQuery(SAMPLE_PROVIDER, DEFAULT_TEST_QUERY);
const stageIndexes = [0];
setup({ query, stageIndexes });
diff --git a/frontend/src/metabase/querying/filters/components/FilterPicker/FilterValuePicker/FilterValuePicker.unit.spec.tsx b/frontend/src/metabase/querying/filters/components/FilterPicker/FilterValuePicker/FilterValuePicker.unit.spec.tsx
index 2afcce180a1..5b7a0d07eb8 100644
--- a/frontend/src/metabase/querying/filters/components/FilterPicker/FilterValuePicker/FilterValuePicker.unit.spec.tsx
+++ b/frontend/src/metabase/querying/filters/components/FilterPicker/FilterValuePicker/FilterValuePicker.unit.spec.tsx
@@ -15,9 +15,10 @@ import {
} from "__support__/ui";
import * as Lib from "metabase-lib";
import {
+ DEFAULT_TEST_QUERY,
SAMPLE_METADATA,
columnFinder,
- createQuery,
+ createMetadataProvider,
} from "metabase-lib/test-helpers";
import type {
FieldId,
@@ -1194,7 +1195,8 @@ describe("NumberFilterValuePicker", () => {
});
function createQueryWithMetadata(metadata = SAMPLE_METADATA) {
- const query = createQuery({ metadata });
+ const provider = createMetadataProvider({ metadata });
+ const query = Lib.createTestQuery(provider, DEFAULT_TEST_QUERY);
const stageIndex = 0;
const availableColumns = Lib.filterableColumns(query, stageIndex);
const findColumn = columnFinder(query, availableColumns);
diff --git a/frontend/src/metabase/querying/filters/components/FilterPicker/MultiStageFilterPicker/MultiStageFilterPicker.unit.spec.tsx b/frontend/src/metabase/querying/filters/components/FilterPicker/MultiStageFilterPicker/MultiStageFilterPicker.unit.spec.tsx
index c8bd7ec77ae..cd2efb45dab 100644
--- a/frontend/src/metabase/querying/filters/components/FilterPicker/MultiStageFilterPicker/MultiStageFilterPicker.unit.spec.tsx
+++ b/frontend/src/metabase/querying/filters/components/FilterPicker/MultiStageFilterPicker/MultiStageFilterPicker.unit.spec.tsx
@@ -2,7 +2,8 @@ import userEvent from "@testing-library/user-event";
import { renderWithProviders, screen } from "__support__/ui";
import * as Lib from "metabase-lib";
-import { createQueryWithClauses } from "metabase-lib/test-helpers";
+import { SAMPLE_PROVIDER } from "metabase-lib/test-helpers";
+import { ORDERS_ID } from "metabase-types/api/mocks/presets";
import { MultiStageFilterPicker } from "./MultiStageFilterPicker";
@@ -34,9 +35,14 @@ function setup({ query, canAppendStage = true }: SetupOpts) {
describe("MultiStageFilterPicker", () => {
it("should drop empty stages if there is no filter in a post-aggregation stage (metabase#57573)", async () => {
const { getNewQuery } = setup({
- query: createQueryWithClauses({
- aggregations: [{ operatorName: "count" }],
- breakouts: [{ tableName: "PRODUCTS", columnName: "CATEGORY" }],
+ query: Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
+ {
+ source: { type: "table", id: ORDERS_ID },
+ aggregations: [{ type: "operator", operator: "count", args: [] }],
+ breakouts: [{ type: "column", name: "CATEGORY" }],
+ },
+ ],
}),
});
expect(screen.getByText("Summaries")).toBeInTheDocument();
@@ -52,9 +58,14 @@ describe("MultiStageFilterPicker", () => {
it("should not drop the post-aggregation stage if there is a new filter", async () => {
const { getNewQuery } = setup({
- query: createQueryWithClauses({
- aggregations: [{ operatorName: "count" }],
- breakouts: [{ tableName: "PRODUCTS", columnName: "CATEGORY" }],
+ query: Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
+ {
+ source: { type: "table", id: ORDERS_ID },
+ aggregations: [{ type: "operator", operator: "count", args: [] }],
+ breakouts: [{ type: "column", name: "CATEGORY" }],
+ },
+ ],
}),
});
expect(screen.getByText("Summaries")).toBeInTheDocument();
diff --git a/frontend/src/metabase/querying/filters/components/FilterPicker/test-utils.ts b/frontend/src/metabase/querying/filters/components/FilterPicker/test-utils.ts
index 8c3282f6c96..ff34c7e9879 100644
--- a/frontend/src/metabase/querying/filters/components/FilterPicker/test-utils.ts
+++ b/frontend/src/metabase/querying/filters/components/FilterPicker/test-utils.ts
@@ -6,8 +6,9 @@ import { checkNotNull } from "metabase/lib/types";
import { getMetadata } from "metabase/selectors/metadata";
import * as Lib from "metabase-lib";
import {
- createQuery as _createQuery,
+ DEFAULT_TEST_QUERY,
columnFinder,
+ createMetadataProvider,
} from "metabase-lib/test-helpers";
import { TYPE } from "metabase-lib/v1/types/constants";
import { createMockField, createMockSegment } from "metabase-types/api/mocks";
@@ -124,9 +125,10 @@ export const storeInitialState = createMockState({
});
export const metadata = getMetadata(storeInitialState);
+const provider = createMetadataProvider({ metadata });
export function createQuery() {
- return _createQuery({ metadata });
+ return Lib.createTestQuery(provider, DEFAULT_TEST_QUERY);
}
export function createFilteredQuery(
diff --git a/frontend/src/metabase/querying/filters/components/TimeseriesChrome/TimeseriesBucketPicker/TimeseriesBucketPicker.unit.spec.tsx b/frontend/src/metabase/querying/filters/components/TimeseriesChrome/TimeseriesBucketPicker/TimeseriesBucketPicker.unit.spec.tsx
index 884d02df30d..a45f96b9765 100644
--- a/frontend/src/metabase/querying/filters/components/TimeseriesChrome/TimeseriesBucketPicker/TimeseriesBucketPicker.unit.spec.tsx
+++ b/frontend/src/metabase/querying/filters/components/TimeseriesChrome/TimeseriesBucketPicker/TimeseriesBucketPicker.unit.spec.tsx
@@ -3,42 +3,42 @@ import userEvent from "@testing-library/user-event";
import { renderWithProviders, screen } from "__support__/ui";
import { checkNotNull } from "metabase/lib/types";
import * as Lib from "metabase-lib";
-import {
- columnFinder,
- createQuery,
- findTemporalBucket,
-} from "metabase-lib/test-helpers";
+import { SAMPLE_PROVIDER } from "metabase-lib/test-helpers";
+import type { TemporalUnit, TestColumnSpec } from "metabase-types/api";
+import { ORDERS_ID } from "metabase-types/api/mocks/presets";
import { TimeseriesBucketPicker } from "./TimeseriesBucketPicker";
-function findBreakoutColumn(query: Lib.Query) {
- const columns = Lib.breakoutableColumns(query, 0);
- const findColumn = columnFinder(query, columns);
- return findColumn("ORDERS", "CREATED_AT");
-}
-
-function findMonthBucket(query: Lib.Query, column: Lib.ColumnMetadata) {
- return findTemporalBucket(query, column, "Month");
-}
-
interface QueryWithBreakoutOpts {
query?: Lib.Query;
stageIndex?: number;
- column?: Lib.ColumnMetadata;
- bucket?: Lib.Bucket | null;
+ column?: TestColumnSpec;
+ bucket?: TemporalUnit | null;
}
function createQueryWithBreakout({
- query: initialQuery = createQuery(),
- column = findBreakoutColumn(initialQuery),
- bucket = findMonthBucket(initialQuery, column),
+ column = {
+ type: "column",
+ sourceName: "ORDERS",
+ name: "CREATED_AT",
+ },
+ bucket = "month",
stageIndex = -1,
}: QueryWithBreakoutOpts = {}) {
- const query = Lib.breakout(
- initialQuery,
- stageIndex,
- Lib.withTemporalBucket(column, bucket),
- );
+ const query = Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
+ {
+ source: { type: "table", id: ORDERS_ID },
+ breakouts: [
+ {
+ ...column,
+ unit: bucket ?? undefined,
+ },
+ ],
+ },
+ ],
+ });
+
const [breakout] = Lib.breakouts(query, stageIndex);
return {
query,
@@ -122,18 +122,9 @@ describe("TimeseriesBucketPicker", () => {
});
it("should show all options when the current bucket is below the More button", async () => {
- const initialQuery = createQuery();
- const initialColumn = findBreakoutColumn(initialQuery);
- const bucket = findTemporalBucket(
- initialQuery,
- initialColumn,
- "Quarter of year",
- );
-
const { query, breakout, column } = createQueryWithBreakout({
- query: initialQuery,
- column: initialColumn,
- bucket,
+ column: { type: "column", sourceName: "ORDERS", name: "CREATED_AT" },
+ bucket: "quarter-of-year",
});
setup({ query, breakout, column });
diff --git a/frontend/src/metabase/querying/filters/components/TimeseriesChrome/TimeseriesChrome.unit.spec.tsx b/frontend/src/metabase/querying/filters/components/TimeseriesChrome/TimeseriesChrome.unit.spec.tsx
index 7f80577b747..2df1ff792bd 100644
--- a/frontend/src/metabase/querying/filters/components/TimeseriesChrome/TimeseriesChrome.unit.spec.tsx
+++ b/frontend/src/metabase/querying/filters/components/TimeseriesChrome/TimeseriesChrome.unit.spec.tsx
@@ -3,12 +3,13 @@ import userEvent from "@testing-library/user-event";
import { renderWithProviders, screen } from "__support__/ui";
import * as Lib from "metabase-lib";
import {
+ DEFAULT_TEST_QUERY,
SAMPLE_METADATA,
- createQuery,
- createQueryWithClauses,
+ SAMPLE_PROVIDER,
} from "metabase-lib/test-helpers";
import Question from "metabase-lib/v1/Question";
import { createMockCard } from "metabase-types/api/mocks";
+import { ORDERS_ID } from "metabase-types/api/mocks/presets";
import { TimeseriesChrome } from "./TimeseriesChrome";
@@ -16,7 +17,9 @@ interface SetupOpts {
query?: Lib.Query;
}
-function setup({ query = createQuery() }: SetupOpts = {}) {
+function setup({
+ query = Lib.createTestQuery(SAMPLE_PROVIDER, DEFAULT_TEST_QUERY),
+}: SetupOpts = {}) {
const question = new Question(createMockCard(), SAMPLE_METADATA).setQuery(
query,
);
@@ -45,20 +48,37 @@ describe("TimeseriesChrome", () => {
});
it("should not render the chrome if there are no breakouts on a temporal column", () => {
- const query = createQueryWithClauses({
- breakouts: [{ tableName: "PRODUCTS", columnName: "CATEGORY" }],
+ const query = Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
+ {
+ source: {
+ type: "table",
+ id: ORDERS_ID,
+ },
+ breakouts: [{ type: "column", name: "CATEGORY" }],
+ },
+ ],
});
setup({ query });
expect(screen.queryByText("View")).not.toBeInTheDocument();
});
it("should allow to change the temporal unit for a breakout", async () => {
- const query = createQueryWithClauses({
- breakouts: [
+ const query = Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
{
- tableName: "PRODUCTS",
- columnName: "CREATED_AT",
- temporalBucketName: "Month",
+ source: {
+ type: "table",
+ id: ORDERS_ID,
+ },
+ breakouts: [
+ {
+ type: "column",
+ sourceName: "ORDERS",
+ name: "CREATED_AT",
+ unit: "month",
+ },
+ ],
},
],
});
@@ -73,17 +93,27 @@ describe("TimeseriesChrome", () => {
});
it("should allow to change the temporal unit for a breakout when there are multiple breakouts of the same column", async () => {
- const query = createQueryWithClauses({
- breakouts: [
- {
- tableName: "PRODUCTS",
- columnName: "CREATED_AT",
- temporalBucketName: "Month",
- },
+ const query = Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
{
- tableName: "PRODUCTS",
- columnName: "CREATED_AT",
- temporalBucketName: "Year",
+ source: {
+ type: "table",
+ id: ORDERS_ID,
+ },
+ breakouts: [
+ {
+ type: "column",
+ sourceName: "ORDERS",
+ name: "CREATED_AT",
+ unit: "month",
+ },
+ {
+ type: "column",
+ sourceName: "ORDERS",
+ name: "CREATED_AT",
+ unit: "year",
+ },
+ ],
},
],
});
diff --git a/frontend/src/metabase/querying/filters/components/TimeseriesChrome/TimeseriesFilterPicker/TimeseriesFilterPicker.unit.spec.tsx b/frontend/src/metabase/querying/filters/components/TimeseriesChrome/TimeseriesFilterPicker/TimeseriesFilterPicker.unit.spec.tsx
index 4f608f8c69f..b837dd05c9c 100644
--- a/frontend/src/metabase/querying/filters/components/TimeseriesChrome/TimeseriesFilterPicker/TimeseriesFilterPicker.unit.spec.tsx
+++ b/frontend/src/metabase/querying/filters/components/TimeseriesChrome/TimeseriesFilterPicker/TimeseriesFilterPicker.unit.spec.tsx
@@ -2,7 +2,11 @@ import _userEvent from "@testing-library/user-event";
import { renderWithProviders, screen } from "__support__/ui";
import * as Lib from "metabase-lib";
-import { columnFinder, createQuery } from "metabase-lib/test-helpers";
+import {
+ DEFAULT_TEST_QUERY,
+ SAMPLE_PROVIDER,
+ columnFinder,
+} from "metabase-lib/test-helpers";
import { TimeseriesFilterPicker } from "./TimeseriesFilterPicker";
@@ -22,7 +26,7 @@ function createDateFilter(query: Lib.Query) {
}
function createQueryWithFilter(
- initialQuery: Lib.Query = createQuery(),
+ initialQuery = Lib.createTestQuery(SAMPLE_PROVIDER, DEFAULT_TEST_QUERY),
clause = createDateFilter(initialQuery),
) {
const query = Lib.filter(initialQuery, 0, clause);
@@ -42,7 +46,7 @@ const userEvent = _userEvent.setup({
});
function setup({
- query = createQuery(),
+ query = Lib.createTestQuery(SAMPLE_PROVIDER, DEFAULT_TEST_QUERY),
column = findDateColumn(query),
filter,
}: SetupOpts = {}) {
diff --git a/frontend/src/metabase/querying/filters/hooks/use-boolean-filter/use-boolean-filter.unit.spec.ts b/frontend/src/metabase/querying/filters/hooks/use-boolean-filter/use-boolean-filter.unit.spec.ts
index f2194d0ab68..6edfafc56de 100644
--- a/frontend/src/metabase/querying/filters/hooks/use-boolean-filter/use-boolean-filter.unit.spec.ts
+++ b/frontend/src/metabase/querying/filters/hooks/use-boolean-filter/use-boolean-filter.unit.spec.ts
@@ -3,7 +3,11 @@ import { act, renderHook } from "@testing-library/react";
import { createMockMetadata } from "__support__/metadata";
import type { BooleanFilterValue } from "metabase/querying/common/types";
import * as Lib from "metabase-lib";
-import { columnFinder, createQuery } from "metabase-lib/test-helpers";
+import {
+ DEFAULT_TEST_QUERY,
+ columnFinder,
+ createMetadataProvider,
+} from "metabase-lib/test-helpers";
import { createMockField } from "metabase-types/api/mocks";
import {
ORDERS_ID,
@@ -47,8 +51,10 @@ const METADATA = createMockMetadata({
],
});
+const PROVIDER = createMetadataProvider({ metadata: METADATA });
+
describe("useBooleanOptionFilter", () => {
- const defaultQuery = createQuery({ metadata: METADATA });
+ const defaultQuery = Lib.createTestQuery(PROVIDER, DEFAULT_TEST_QUERY);
const stageIndex = 0;
const availableColumns = Lib.filterableColumns(defaultQuery, stageIndex);
const column = columnFinder(defaultQuery, availableColumns)(
diff --git a/frontend/src/metabase/querying/filters/hooks/use-coordinate-filter/use-coordinate-filter.unit.spec.ts b/frontend/src/metabase/querying/filters/hooks/use-coordinate-filter/use-coordinate-filter.unit.spec.ts
index 2a39abb2dc4..997bde5f24e 100644
--- a/frontend/src/metabase/querying/filters/hooks/use-coordinate-filter/use-coordinate-filter.unit.spec.ts
+++ b/frontend/src/metabase/querying/filters/hooks/use-coordinate-filter/use-coordinate-filter.unit.spec.ts
@@ -2,7 +2,7 @@ import { act, renderHook } from "@testing-library/react";
import { checkNotNull } from "metabase/lib/types";
import * as Lib from "metabase-lib";
-import { columnFinder, createQuery } from "metabase-lib/test-helpers";
+import { SAMPLE_PROVIDER, columnFinder } from "metabase-lib/test-helpers";
import { PEOPLE_ID } from "metabase-types/api/mocks/presets";
import type { NumberOrEmptyValue } from "./types";
@@ -33,7 +33,16 @@ interface ValidateFilterCase {
}
describe("useCoordinateFilter", () => {
- const defaultQuery = Lib.withDifferentTable(createQuery(), PEOPLE_ID);
+ const defaultQuery = Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
+ {
+ source: {
+ type: "table",
+ id: PEOPLE_ID,
+ },
+ },
+ ],
+ });
const stageIndex = 0;
const availableColumns = Lib.filterableColumns(defaultQuery, stageIndex);
const latitudeColumn = columnFinder(defaultQuery, availableColumns)(
diff --git a/frontend/src/metabase/querying/filters/hooks/use-date-filter/use-date-filter.unit.spec.ts b/frontend/src/metabase/querying/filters/hooks/use-date-filter/use-date-filter.unit.spec.ts
index ba09550b9fc..74bdc3743d1 100644
--- a/frontend/src/metabase/querying/filters/hooks/use-date-filter/use-date-filter.unit.spec.ts
+++ b/frontend/src/metabase/querying/filters/hooks/use-date-filter/use-date-filter.unit.spec.ts
@@ -3,15 +3,16 @@ import { renderHook } from "@testing-library/react";
import type { DatePickerValue } from "metabase/querying/common/types";
import * as Lib from "metabase-lib";
import {
+ DEFAULT_TEST_QUERY,
+ SAMPLE_PROVIDER,
columnFinder,
- createQuery,
- createQueryWithClauses,
} from "metabase-lib/test-helpers";
+import { ORDERS_ID } from "metabase-types/api/mocks/presets";
import { useDateFilter } from "./use-date-filter";
describe("useDateFilter", () => {
- const defaultQuery = createQuery();
+ const defaultQuery = Lib.createTestQuery(SAMPLE_PROVIDER, DEFAULT_TEST_QUERY);
const stageIndex = 0;
const availableColumns = Lib.filterableColumns(defaultQuery, stageIndex);
const defaultColumn = columnFinder(defaultQuery, availableColumns)(
@@ -75,20 +76,29 @@ describe("useDateFilter", () => {
});
it("should return available units for a custom column", () => {
- const query = createQueryWithClauses({
- query: defaultQuery,
- expressions: [
+ const query = Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
{
- name: "CustomDate",
- operator: "=",
- args: [defaultColumn],
+ source: { type: "table", id: ORDERS_ID },
+ expressions: [
+ {
+ name: "CustomDate",
+ value: {
+ type: "operator",
+ operator: "=",
+ args: [
+ { type: "column", name: "CREATED_AT", sourceName: "ORDERS" },
+ ],
+ },
+ },
+ ],
},
],
});
const column = columnFinder(
query,
Lib.filterableColumns(query, stageIndex),
- )("ORDERS", "CustomDate");
+ )(null, "CustomDate");
const { result } = renderHook(() =>
useDateFilter({
diff --git a/frontend/src/metabase/querying/filters/hooks/use-default-filter/use-default-filter.unit.spec.ts b/frontend/src/metabase/querying/filters/hooks/use-default-filter/use-default-filter.unit.spec.ts
index fd9bd229873..0c93cf1bcb0 100644
--- a/frontend/src/metabase/querying/filters/hooks/use-default-filter/use-default-filter.unit.spec.ts
+++ b/frontend/src/metabase/querying/filters/hooks/use-default-filter/use-default-filter.unit.spec.ts
@@ -3,7 +3,11 @@ import { act, renderHook } from "@testing-library/react";
import { createMockMetadata } from "__support__/metadata";
import { checkNotNull } from "metabase/lib/types";
import * as Lib from "metabase-lib";
-import { columnFinder, createQuery } from "metabase-lib/test-helpers";
+import {
+ DEFAULT_TEST_QUERY,
+ columnFinder,
+ createMetadataProvider,
+} from "metabase-lib/test-helpers";
import { createMockField } from "metabase-types/api/mocks";
import {
ORDERS_ID,
@@ -47,8 +51,10 @@ const METADATA = createMockMetadata({
],
});
+const PROVIDER = createMetadataProvider({ metadata: METADATA });
+
describe("useDefaultFilter", () => {
- const defaultQuery = createQuery({ metadata: METADATA });
+ const defaultQuery = Lib.createTestQuery(PROVIDER, DEFAULT_TEST_QUERY);
const stageIndex = 0;
const availableColumns = Lib.filterableColumns(defaultQuery, stageIndex);
const column = columnFinder(defaultQuery, availableColumns)(
diff --git a/frontend/src/metabase/querying/filters/hooks/use-number-filter/use-number-filter.unit.spec.ts b/frontend/src/metabase/querying/filters/hooks/use-number-filter/use-number-filter.unit.spec.ts
index 6f2a3fba6b4..a2d6deb0034 100644
--- a/frontend/src/metabase/querying/filters/hooks/use-number-filter/use-number-filter.unit.spec.ts
+++ b/frontend/src/metabase/querying/filters/hooks/use-number-filter/use-number-filter.unit.spec.ts
@@ -3,7 +3,11 @@ import { act, renderHook } from "@testing-library/react";
import { createMockMetadata } from "__support__/metadata";
import { checkNotNull } from "metabase/lib/types";
import * as Lib from "metabase-lib";
-import { columnFinder, createQuery } from "metabase-lib/test-helpers";
+import {
+ DEFAULT_TEST_QUERY,
+ columnFinder,
+ createMetadataProvider,
+} from "metabase-lib/test-helpers";
import {
createOrdersIdField,
createOrdersProductIdField,
@@ -67,8 +71,10 @@ const METADATA = createMockMetadata({
],
});
+const PROVIDER = createMetadataProvider({ metadata: METADATA });
+
describe("useNumberFilter", () => {
- const defaultQuery = createQuery({ metadata: METADATA });
+ const defaultQuery = Lib.createTestQuery(PROVIDER, DEFAULT_TEST_QUERY);
const stageIndex = 0;
const availableColumns = Lib.filterableColumns(defaultQuery, stageIndex);
const findColumn = columnFinder(defaultQuery, availableColumns);
diff --git a/frontend/src/metabase/querying/filters/hooks/use-string-filter/use-string-filter.unit.spec.ts b/frontend/src/metabase/querying/filters/hooks/use-string-filter/use-string-filter.unit.spec.ts
index f700c6c7212..48152fa0466 100644
--- a/frontend/src/metabase/querying/filters/hooks/use-string-filter/use-string-filter.unit.spec.ts
+++ b/frontend/src/metabase/querying/filters/hooks/use-string-filter/use-string-filter.unit.spec.ts
@@ -3,7 +3,11 @@ import { act, renderHook } from "@testing-library/react";
import { createMockMetadata } from "__support__/metadata";
import { checkNotNull } from "metabase/lib/types";
import * as Lib from "metabase-lib";
-import { columnFinder, createQuery } from "metabase-lib/test-helpers";
+import {
+ DEFAULT_TEST_QUERY,
+ columnFinder,
+ createMetadataProvider,
+} from "metabase-lib/test-helpers";
import {
createOrdersIdField,
createOrdersProductIdField,
@@ -78,8 +82,10 @@ const METADATA = createMockMetadata({
],
});
+const PROVIDER = createMetadataProvider({ metadata: METADATA });
+
describe("useStringFilter", () => {
- const defaultQuery = createQuery({ metadata: METADATA });
+ const defaultQuery = Lib.createTestQuery(PROVIDER, DEFAULT_TEST_QUERY);
const stageIndex = 0;
const availableColumns = Lib.filterableColumns(defaultQuery, stageIndex);
const findColumn = columnFinder(defaultQuery, availableColumns);
diff --git a/frontend/src/metabase/querying/filters/hooks/use-time-filter/use-time-filter.unit.spec.ts b/frontend/src/metabase/querying/filters/hooks/use-time-filter/use-time-filter.unit.spec.ts
index bf8b814bf7d..d61230f732e 100644
--- a/frontend/src/metabase/querying/filters/hooks/use-time-filter/use-time-filter.unit.spec.ts
+++ b/frontend/src/metabase/querying/filters/hooks/use-time-filter/use-time-filter.unit.spec.ts
@@ -3,7 +3,11 @@ import { act, renderHook } from "@testing-library/react";
import { createMockMetadata } from "__support__/metadata";
import { checkNotNull } from "metabase/lib/types";
import * as Lib from "metabase-lib";
-import { columnFinder, createQuery } from "metabase-lib/test-helpers";
+import {
+ DEFAULT_TEST_QUERY,
+ columnFinder,
+ createMetadataProvider,
+} from "metabase-lib/test-helpers";
import { createMockField } from "metabase-types/api/mocks";
import {
ORDERS_ID,
@@ -63,8 +67,10 @@ const METADATA = createMockMetadata({
],
});
+const PROVIDER = createMetadataProvider({ metadata: METADATA });
+
describe("useTimeFilter", () => {
- const defaultQuery = createQuery({ metadata: METADATA });
+ const defaultQuery = Lib.createTestQuery(PROVIDER, DEFAULT_TEST_QUERY);
const stageIndex = 0;
const availableColumns = Lib.filterableColumns(defaultQuery, stageIndex);
const column = columnFinder(defaultQuery, availableColumns)(
diff --git a/frontend/src/metabase/querying/filters/utils/dates.unit.spec.ts b/frontend/src/metabase/querying/filters/utils/dates.unit.spec.ts
index 577e84e480d..abf2e6dba35 100644
--- a/frontend/src/metabase/querying/filters/utils/dates.unit.spec.ts
+++ b/frontend/src/metabase/querying/filters/utils/dates.unit.spec.ts
@@ -1,7 +1,11 @@
import { setLocalization } from "metabase/lib/i18n";
import type { DateFilterValue } from "metabase/querying/common/types";
import * as Lib from "metabase-lib";
-import { columnFinder, createQuery } from "metabase-lib/test-helpers";
+import {
+ DEFAULT_TEST_QUERY,
+ SAMPLE_PROVIDER,
+ columnFinder,
+} from "metabase-lib/test-helpers";
import type { DateFormattingSettings } from "metabase-types/api";
import {
@@ -16,7 +20,7 @@ type DateFilterClauseCase = {
};
describe("getDateFilterClause", () => {
- const query = createQuery();
+ const query = Lib.createTestQuery(SAMPLE_PROVIDER, DEFAULT_TEST_QUERY);
const stageIndex = 0;
const columns = Lib.filterableColumns(query, stageIndex);
const findColumn = columnFinder(query, columns);
diff --git a/frontend/src/metabase/querying/notebook/components/AggregateStep/AggregateStep.unit.spec.tsx b/frontend/src/metabase/querying/notebook/components/AggregateStep/AggregateStep.unit.spec.tsx
index 0de7fc8e298..603c7e311e0 100644
--- a/frontend/src/metabase/querying/notebook/components/AggregateStep/AggregateStep.unit.spec.tsx
+++ b/frontend/src/metabase/querying/notebook/components/AggregateStep/AggregateStep.unit.spec.tsx
@@ -7,8 +7,9 @@ import {
screen,
} from "__support__/ui";
import * as Lib from "metabase-lib";
-import { createQueryWithClauses } from "metabase-lib/test-helpers";
+import { SAMPLE_PROVIDER } from "metabase-lib/test-helpers";
import { createMockCard } from "metabase-types/api/mocks";
+import { ORDERS_ID } from "metabase-types/api/mocks/presets";
import {
createMockQueryBuilderState,
createMockState,
@@ -20,9 +21,21 @@ import type { NotebookStep } from "../../types";
import { AggregateStep } from "./AggregateStep";
function createAggregatedQuery() {
- return createQueryWithClauses({
- aggregations: [
- { operatorName: "avg", tableName: "ORDERS", columnName: "QUANTITY" },
+ return Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
+ {
+ source: {
+ type: "table",
+ id: ORDERS_ID,
+ },
+ aggregations: [
+ {
+ type: "operator",
+ operator: "avg",
+ args: [{ type: "column", sourceName: "ORDERS", name: "QUANTITY" }],
+ },
+ ],
+ },
],
});
}
@@ -85,12 +98,25 @@ describe("AggregateStep", () => {
it("should use foreign key name for foreign table columns", () => {
setup({
step: createMockNotebookStep({
- query: createQueryWithClauses({
- aggregations: [
+ query: Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
{
- operatorName: "avg",
- tableName: "PRODUCTS",
- columnName: "RATING",
+ source: {
+ type: "table",
+ id: ORDERS_ID,
+ },
+ aggregations: [
+ {
+ type: "operator",
+ operator: "avg",
+ args: [
+ {
+ type: "column",
+ name: "RATING",
+ },
+ ],
+ },
+ ],
},
],
}),
@@ -180,8 +206,16 @@ describe("AggregateStep", () => {
// TODO: unskip this once we enable "Compare to the past" again
// eslint-disable-next-line jest/no-disabled-tests
it.skip("should not allow to use temporal comparisons for metrics", async () => {
- const query = createQueryWithClauses({
- aggregations: [{ operatorName: "count" }],
+ const query = Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
+ {
+ source: {
+ type: "table",
+ id: ORDERS_ID,
+ },
+ aggregations: [{ type: "operator", operator: "count", args: [] }],
+ },
+ ],
});
const question = DEFAULT_QUESTION.setType("metric").setQuery(query);
const step = createMockNotebookStep({ question, query });
@@ -195,8 +229,16 @@ describe("AggregateStep", () => {
// TODO: unskip this once we enable "Compare to the past" again
// eslint-disable-next-line jest/no-disabled-tests
it.skip("should allow to use temporal comparisons for non-metrics", async () => {
- const query = createQueryWithClauses({
- aggregations: [{ operatorName: "count" }],
+ const query = Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
+ {
+ source: {
+ type: "table",
+ id: ORDERS_ID,
+ },
+ aggregations: [{ type: "operator", operator: "count", args: [] }],
+ },
+ ],
});
const question = DEFAULT_QUESTION.setType("question").setQuery(query);
const step = createMockNotebookStep({ question, query });
diff --git a/frontend/src/metabase/querying/notebook/components/BreakoutStep/BreakoutStep.unit.spec.tsx b/frontend/src/metabase/querying/notebook/components/BreakoutStep/BreakoutStep.unit.spec.tsx
index 44d22e62b30..ca4526befd9 100644
--- a/frontend/src/metabase/querying/notebook/components/BreakoutStep/BreakoutStep.unit.spec.tsx
+++ b/frontend/src/metabase/querying/notebook/components/BreakoutStep/BreakoutStep.unit.spec.tsx
@@ -10,10 +10,12 @@ import {
within,
} from "__support__/ui";
import * as Lib from "metabase-lib";
-import { createQueryWithClauses } from "metabase-lib/test-helpers";
+import { SAMPLE_PROVIDER } from "metabase-lib/test-helpers";
import Question from "metabase-lib/v1/Question";
+import type { TemporalUnit } from "metabase-types/api";
import { createMockCard } from "metabase-types/api/mocks";
import {
+ ORDERS_ID,
createOrdersIdField,
createOrdersTable,
createSampleDatabase,
@@ -25,66 +27,110 @@ import type { NotebookStep } from "../../types";
import { BreakoutStep } from "./BreakoutStep";
function createQueryWithBreakout() {
- return createQueryWithClauses({
- breakouts: [{ tableName: "ORDERS", columnName: "TAX" }],
+ return Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
+ {
+ source: {
+ type: "table",
+ id: ORDERS_ID,
+ },
+ breakouts: [
+ {
+ type: "column",
+ sourceName: "ORDERS",
+ name: "TAX",
+ },
+ ],
+ },
+ ],
});
}
-function createQueryWithBreakoutAndBinningStrategy(
- binningStrategyName = "10 bins",
+function createQueryWithBreakoutAndBinningCount(
+ binningCount: number | undefined,
) {
- return createQueryWithClauses({
- breakouts: [
+ return Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
{
- tableName: "ORDERS",
- columnName: "TAX",
- binningStrategyName,
+ source: {
+ type: "table",
+ id: ORDERS_ID,
+ },
+ breakouts: [
+ {
+ type: "column",
+ sourceName: "ORDERS",
+ name: "TAX",
+ bins: binningCount,
+ },
+ ],
},
],
});
}
function createQueryWithMultipleBreakoutsAndBinningStrategy() {
- return createQueryWithClauses({
- breakouts: [
- {
- tableName: "ORDERS",
- columnName: "TAX",
- binningStrategyName: "10 bins",
- },
+ return Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
{
- tableName: "ORDERS",
- columnName: "TAX",
- binningStrategyName: "50 bins",
+ source: {
+ type: "table",
+ id: ORDERS_ID,
+ },
+ breakouts: [
+ { type: "column", sourceName: "ORDERS", name: "TAX", bins: 10 },
+ { type: "column", sourceName: "ORDERS", name: "TAX", bins: 50 },
+ ],
},
],
});
}
-function createQueryWithBreakoutAndTemporalBucket(temporalBucketName: string) {
- return createQueryWithClauses({
- breakouts: [
+function createQueryWithBreakoutAndTemporalBucket(
+ temporalBucketName: TemporalUnit | undefined,
+) {
+ return Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
{
- tableName: "ORDERS",
- columnName: "CREATED_AT",
- temporalBucketName,
+ source: {
+ type: "table",
+ id: ORDERS_ID,
+ },
+ breakouts: [
+ {
+ type: "column",
+ sourceName: "ORDERS",
+ name: "CREATED_AT",
+ unit: temporalBucketName,
+ },
+ ],
},
],
});
}
function createQueryWithMultipleBreakoutsAndTemporalBucket() {
- return createQueryWithClauses({
- breakouts: [
+ return Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
{
- tableName: "ORDERS",
- columnName: "CREATED_AT",
- temporalBucketName: "Year",
- },
- {
- tableName: "ORDERS",
- columnName: "CREATED_AT",
- temporalBucketName: "Month",
+ source: {
+ type: "table",
+ id: ORDERS_ID,
+ },
+ breakouts: [
+ {
+ type: "column",
+ sourceName: "ORDERS",
+ name: "CREATED_AT",
+ unit: "year",
+ },
+ {
+ type: "column",
+ sourceName: "ORDERS",
+ name: "CREATED_AT",
+ unit: "month",
+ },
+ ],
},
],
});
@@ -209,7 +255,7 @@ describe("BreakoutStep", () => {
});
it("should highlight selected binning strategy", async () => {
- const query = createQueryWithBreakoutAndBinningStrategy();
+ const query = createQueryWithBreakoutAndBinningCount(10);
setup({ step: createMockNotebookStep({ query }) });
await userEvent.click(screen.getByText("Tax: 10 bins"));
@@ -222,7 +268,7 @@ describe("BreakoutStep", () => {
});
it("shouldn't update a query when clicking a selected binned column", async () => {
- const query = createQueryWithBreakoutAndBinningStrategy();
+ const query = createQueryWithBreakoutAndBinningCount(10);
const { updateQuery } = setup({
step: createMockNotebookStep({ query }),
});
@@ -234,7 +280,7 @@ describe("BreakoutStep", () => {
});
it("should highlight the `Don't bin` option when a column is not binned", async () => {
- const query = createQueryWithBreakoutAndBinningStrategy("Don't bin");
+ const query = createQueryWithBreakoutAndBinningCount(undefined);
setup({ step: createMockNotebookStep({ query }) });
await userEvent.click(screen.getByText("Tax"));
@@ -276,7 +322,7 @@ describe("BreakoutStep", () => {
});
it("should highlight selected temporal bucket", async () => {
- const query = createQueryWithBreakoutAndTemporalBucket("Quarter");
+ const query = createQueryWithBreakoutAndTemporalBucket("quarter");
setup({ step: createMockNotebookStep({ query }) });
await userEvent.click(screen.getByText("Created At: Quarter"));
@@ -289,7 +335,7 @@ describe("BreakoutStep", () => {
});
it("should handle `Don't bin` option for temporal bucket (metabase#19684)", async () => {
- const query = createQueryWithBreakoutAndTemporalBucket("Don't bin");
+ const query = createQueryWithBreakoutAndTemporalBucket(undefined);
setup({ step: createMockNotebookStep({ query }) });
await userEvent.click(screen.getByText("Created At"));
@@ -311,7 +357,7 @@ describe("BreakoutStep", () => {
});
it("shouldn't update a query when clicking a selected column with temporal bucketing", async () => {
- const query = createQueryWithBreakoutAndTemporalBucket("Quarter");
+ const query = createQueryWithBreakoutAndTemporalBucket("quarter");
const { updateQuery } = setup({
step: createMockNotebookStep({ query }),
});
@@ -323,7 +369,7 @@ describe("BreakoutStep", () => {
});
it("should allow to add a breakout for a column with an existing breakout but with a different binning strategy", async () => {
- const query = createQueryWithBreakoutAndBinningStrategy("10 bins");
+ const query = createQueryWithBreakoutAndBinningCount(10);
const { getNextBreakouts } = setup({
step: createMockNotebookStep({ query }),
});
@@ -340,7 +386,7 @@ describe("BreakoutStep", () => {
});
it("should ignore attempts to add a breakout for a column with the same binning strategy", async () => {
- const query = createQueryWithBreakoutAndBinningStrategy("10 bins");
+ const query = createQueryWithBreakoutAndBinningCount(10);
const { getNextBreakouts } = setup({
step: createMockNotebookStep({ query }),
});
@@ -404,7 +450,7 @@ describe("BreakoutStep", () => {
});
it("should allow to add a breakout for a column with an existing breakout but with a different temporal bucket", async () => {
- const query = createQueryWithBreakoutAndTemporalBucket("Year");
+ const query = createQueryWithBreakoutAndTemporalBucket("year");
const { getNextBreakouts } = setup({
step: createMockNotebookStep({ query }),
});
@@ -421,7 +467,7 @@ describe("BreakoutStep", () => {
});
it("should ignore attempts to add a breakout for a column with the same temporal bucket", async () => {
- const query = createQueryWithBreakoutAndTemporalBucket("Year");
+ const query = createQueryWithBreakoutAndTemporalBucket("year");
const { getNextBreakouts } = setup({
step: createMockNotebookStep({ query }),
});
@@ -547,8 +593,18 @@ describe("BreakoutStep", () => {
});
it("should not allow to add more than 1 breakout", async () => {
- const query = createQueryWithClauses({
- breakouts: [{ tableName: "ORDERS", columnName: "CREATED_AT" }],
+ const query = Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
+ {
+ source: {
+ type: "table",
+ id: ORDERS_ID,
+ },
+ breakouts: [
+ { type: "column", sourceName: "ORDERS", name: "CREATED_AT" },
+ ],
+ },
+ ],
});
const question = DEFAULT_QUESTION.setType("metric").setQuery(query);
const step = createMockNotebookStep({ question });
diff --git a/frontend/src/metabase/querying/notebook/components/DataStep/tests/common.unit.spec.tsx b/frontend/src/metabase/querying/notebook/components/DataStep/tests/common.unit.spec.tsx
index 01df6b82be6..f5ea50bfbf0 100644
--- a/frontend/src/metabase/querying/notebook/components/DataStep/tests/common.unit.spec.tsx
+++ b/frontend/src/metabase/querying/notebook/components/DataStep/tests/common.unit.spec.tsx
@@ -7,13 +7,14 @@ import { checkNotNull } from "metabase/lib/types";
import type { IconName } from "metabase/ui";
import * as Lib from "metabase-lib";
import {
+ DEFAULT_TEST_QUERY,
+ SAMPLE_PROVIDER,
columnFinder,
- createQuery,
- findAggregationOperator,
} from "metabase-lib/test-helpers";
import Question from "metabase-lib/v1/Question";
import type { CardType } from "metabase-types/api";
import {
+ ORDERS_ID,
SAMPLE_DB_ID,
createSampleDatabase,
createSavedStructuredCard,
@@ -23,22 +24,45 @@ import { DEFAULT_QUESTION, createMockNotebookStep } from "../../../test-utils";
import { type SetupOpts, setup as baseSetup } from "./setup";
+const findAggregationOperator = (
+ query: Lib.Query,
+ operatorShortName: string,
+) => {
+ const operators = Lib.availableAggregationOperators(query, 0);
+ const operator = operators.find(
+ (operator) =>
+ Lib.displayInfo(query, 0, operator).shortName === operatorShortName,
+ );
+ if (!operator) {
+ throw new Error(`Could not find aggregation operator ${operatorShortName}`);
+ }
+ return operator;
+};
+
const createQueryWithFields = (columnNames: string[]) => {
- const query = createQuery();
- const findColumn = columnFinder(query, Lib.fieldableColumns(query, 0));
- const columns = columnNames.map((name) => findColumn("ORDERS", name));
- return Lib.withFields(query, 0, columns);
+ return Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
+ {
+ source: { type: "table", id: ORDERS_ID },
+ fields: columnNames.map((name) => ({
+ type: "column",
+ sourceName: "ORDERS",
+ name,
+ })),
+ },
+ ],
+ });
};
const createQueryWithAggregation = () => {
- const query = createQuery();
+ const query = Lib.createTestQuery(SAMPLE_PROVIDER, DEFAULT_TEST_QUERY);
const count = findAggregationOperator(query, "count");
const aggregation = Lib.aggregationClause(count);
return Lib.aggregate(query, 0, aggregation);
};
const createQueryWithBreakout = () => {
- const query = createQuery();
+ const query = Lib.createTestQuery(SAMPLE_PROVIDER, DEFAULT_TEST_QUERY);
const columns = Lib.breakoutableColumns(query, 0);
const findColumn = columnFinder(query, columns);
const column = findColumn("ORDERS", "TAX");
diff --git a/frontend/src/metabase/querying/notebook/components/ExpressionStep/ExpressionStep.unit.spec.tsx b/frontend/src/metabase/querying/notebook/components/ExpressionStep/ExpressionStep.unit.spec.tsx
index 4d71d6e0797..d7407bdf373 100644
--- a/frontend/src/metabase/querying/notebook/components/ExpressionStep/ExpressionStep.unit.spec.tsx
+++ b/frontend/src/metabase/querying/notebook/components/ExpressionStep/ExpressionStep.unit.spec.tsx
@@ -2,7 +2,8 @@ import userEvent from "@testing-library/user-event";
import { renderWithProviders, screen, within } from "__support__/ui";
import * as Lib from "metabase-lib";
-import { createQuery, createQueryWithClauses } from "metabase-lib/test-helpers";
+import { DEFAULT_TEST_QUERY, SAMPLE_PROVIDER } from "metabase-lib/test-helpers";
+import { ORDERS_ID } from "metabase-types/api/mocks/presets";
import { createMockNotebookStep } from "../../test-utils";
@@ -12,7 +13,9 @@ interface SetupOpts {
query?: Lib.Query;
}
-function setup({ query = createQuery() }: SetupOpts = {}) {
+function setup({
+ query = Lib.createTestQuery(SAMPLE_PROVIDER, DEFAULT_TEST_QUERY),
+}: SetupOpts = {}) {
const updateQuery = jest.fn();
const step = createMockNotebookStep({
@@ -66,8 +69,28 @@ describe("Notebook Editor > Expression Step", () => {
});
it("should handle updating existing expression", async () => {
- const query = createQueryWithClauses({
- expressions: [{ name: "old name", operator: "+", args: [1, 1] }],
+ const query = Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
+ {
+ source: {
+ type: "table",
+ id: ORDERS_ID,
+ },
+ expressions: [
+ {
+ name: "old name",
+ value: {
+ type: "operator",
+ operator: "+",
+ args: [
+ { type: "literal", value: 1 },
+ { type: "literal", value: 1 },
+ ],
+ },
+ },
+ ],
+ },
+ ],
});
const { getRecentQuery } = setup({ query });
@@ -86,8 +109,28 @@ describe("Notebook Editor > Expression Step", () => {
});
it("should handle removing existing expression", async () => {
- const query = createQueryWithClauses({
- expressions: [{ name: "expression name", operator: "+", args: [1, 1] }],
+ const query = Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
+ {
+ source: {
+ type: "table",
+ id: ORDERS_ID,
+ },
+ expressions: [
+ {
+ name: "expression name",
+ value: {
+ type: "operator",
+ operator: "+",
+ args: [
+ { type: "literal", value: 1 },
+ { type: "literal", value: 1 },
+ ],
+ },
+ },
+ ],
+ },
+ ],
});
const { getRecentQuery } = setup({ query });
diff --git a/frontend/src/metabase/querying/notebook/components/FilterStep/FilterStep.unit.spec.tsx b/frontend/src/metabase/querying/notebook/components/FilterStep/FilterStep.unit.spec.tsx
index 549d32a416c..99812569da6 100644
--- a/frontend/src/metabase/querying/notebook/components/FilterStep/FilterStep.unit.spec.tsx
+++ b/frontend/src/metabase/querying/notebook/components/FilterStep/FilterStep.unit.spec.tsx
@@ -1,18 +1,31 @@
import { renderWithProviders, screen } from "__support__/ui";
import * as Lib from "metabase-lib";
-import { columnFinder, createQuery } from "metabase-lib/test-helpers";
+import { SAMPLE_PROVIDER } from "metabase-lib/test-helpers";
+import { ORDERS_ID } from "metabase-types/api/mocks/presets";
import { createMockNotebookStep } from "../../test-utils";
import { FilterStep } from "./FilterStep";
function createQueryWithFilter() {
- const initialQuery = createQuery();
- const columns = Lib.filterableColumns(initialQuery, 0);
- const findColumn = columnFinder(initialQuery, columns);
- const totalColumn = findColumn("ORDERS", "TOTAL");
- const clause = Lib.expressionClause(">", [totalColumn, 20], null);
- const query = Lib.filter(initialQuery, 0, clause);
+ const query = Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
+ {
+ source: { type: "table", id: ORDERS_ID },
+ filters: [
+ {
+ type: "operator",
+ operator: ">",
+ args: [
+ { type: "column", sourceName: "ORDERS", name: "TOTAL" },
+ { type: "literal", value: 20 },
+ ],
+ },
+ ],
+ },
+ ],
+ });
+
const [filter] = Lib.filters(query, 0);
return { query, filter };
}
diff --git a/frontend/src/metabase/querying/notebook/components/JoinStep/JoinStep.unit.spec.tsx b/frontend/src/metabase/querying/notebook/components/JoinStep/JoinStep.unit.spec.tsx
index e04e55a6ad8..597b463716f 100644
--- a/frontend/src/metabase/querying/notebook/components/JoinStep/JoinStep.unit.spec.tsx
+++ b/frontend/src/metabase/querying/notebook/components/JoinStep/JoinStep.unit.spec.tsx
@@ -21,8 +21,13 @@ import {
} from "__support__/ui";
import { METAKEY } from "metabase/lib/browser";
import * as Lib from "metabase-lib";
-import { createQuery, getJoinQueryHelpers } from "metabase-lib/test-helpers";
-import type { CollectionItem, RecentItem } from "metabase-types/api";
+import { createMetadataProvider } from "metabase-lib/test-helpers";
+import type {
+ CollectionItem,
+ RecentItem,
+ TestColumnWithBinningSpec,
+ TestExpressionSpec,
+} from "metabase-types/api";
import {
createMockCollection,
createMockCollectionItem,
@@ -30,6 +35,7 @@ import {
createMockRecentCollectionItem,
} from "metabase-types/api/mocks";
import {
+ ORDERS_ID,
PRODUCTS_ID,
createSampleDatabase,
createSavedStructuredCard,
@@ -74,90 +80,99 @@ const metadata = createMockMetadata({
questions: [MODEL, QUESTION],
});
+const provider = createMetadataProvider({ metadata });
+
function getJoinedQuery() {
- const query = createQuery({ metadata });
-
- const {
- table,
- defaultStrategy,
- defaultOperator,
- findLHSColumn,
- findRHSColumn,
- } = getJoinQueryHelpers(query, 0, PRODUCTS_ID);
-
- const ordersProductId = findLHSColumn("ORDERS", "PRODUCT_ID");
- const productsId = findRHSColumn("PRODUCTS", "ID");
-
- const stageIndex = -1;
- const condition = Lib.joinConditionClause(
- defaultOperator,
- ordersProductId,
- productsId,
- );
-
- const join = Lib.withJoinFields(
- Lib.joinClause(table, [condition], defaultStrategy),
- "all",
- );
-
- return Lib.join(query, stageIndex, join);
+ return Lib.createTestQuery(provider, {
+ stages: [
+ {
+ source: { type: "table", id: ORDERS_ID },
+ joins: [
+ {
+ source: { type: "table", id: PRODUCTS_ID },
+ strategy: "left-join",
+ conditions: [
+ {
+ operator: "=",
+ left: {
+ type: "column",
+ sourceName: "ORDERS",
+ name: "PRODUCT_ID",
+ },
+ right: { type: "column", sourceName: "PRODUCTS", name: "ID" },
+ },
+ ],
+ },
+ ],
+ },
+ ],
+ });
}
-type FindColumn = (tableName: string, columnName: string) => Lib.ColumnMetadata;
-type CreateExpression = (findColumn: FindColumn) => Lib.ExpressionClause;
-
function getJoinedQueryWithCustomExpressions(
- createLhsExpression: CreateExpression,
- createRhsExpression: CreateExpression,
+ left: TestColumnWithBinningSpec | TestExpressionSpec,
+ right: TestColumnWithBinningSpec | TestExpressionSpec,
) {
- const query = createQuery({ metadata });
- const {
- table,
- defaultStrategy,
- defaultOperator,
- findLHSColumn,
- findRHSColumn,
- } = getJoinQueryHelpers(query, 0, PRODUCTS_ID);
- const stageIndex = -1;
- const condition = Lib.joinConditionClause(
- defaultOperator,
- createLhsExpression(findLHSColumn),
- createRhsExpression(findRHSColumn),
- );
- const join = Lib.withJoinFields(
- Lib.joinClause(table, [condition], defaultStrategy),
- "all",
- );
-
- return Lib.join(query, stageIndex, join);
+ return Lib.createTestQuery(provider, {
+ stages: [
+ {
+ source: { type: "table", id: ORDERS_ID },
+ joins: [
+ {
+ source: { type: "table", id: PRODUCTS_ID },
+ strategy: "left-join",
+ conditions: [
+ {
+ operator: "=",
+ left,
+ right,
+ },
+ ],
+ },
+ ],
+ },
+ ],
+ });
}
function getJoinedQueryWithMultipleConditions() {
- const query = getJoinedQuery();
- const { defaultOperator, findLHSColumn, findRHSColumn } = getJoinQueryHelpers(
- query,
- 0,
- PRODUCTS_ID,
- );
-
- const [currentJoin] = Lib.joins(query, 0);
- const currentConditions = Lib.joinConditions(currentJoin);
-
- const ordersCreatedAt = findLHSColumn("ORDERS", "CREATED_AT");
- const productsCreatedAt = findRHSColumn("PRODUCTS", "CREATED_AT");
-
- const condition = Lib.joinConditionClause(
- defaultOperator,
- ordersCreatedAt,
- productsCreatedAt,
- );
-
- const nextJoin = Lib.withJoinConditions(currentJoin, [
- ...currentConditions,
- condition,
- ]);
-
- return Lib.replaceClause(query, 0, currentJoin, nextJoin);
+ return Lib.createTestQuery(provider, {
+ stages: [
+ {
+ source: { type: "table", id: ORDERS_ID },
+ joins: [
+ {
+ source: { type: "table", id: PRODUCTS_ID },
+ strategy: "left-join",
+ conditions: [
+ {
+ operator: "=",
+ left: {
+ type: "column",
+ sourceName: "ORDERS",
+ name: "PRODUCT_ID",
+ },
+ right: { type: "column", sourceName: "PRODUCTS", name: "ID" },
+ },
+ {
+ operator: "=",
+ left: {
+ type: "column",
+ sourceName: "ORDERS",
+ name: "CREATED_AT",
+ },
+ right: {
+ type: "column",
+ sourceName: "PRODUCTS",
+ name: "CREATED_AT",
+ },
+ },
+ ],
+ },
+ ],
+ },
+ ],
+ });
}
function setup({
@@ -1342,13 +1357,15 @@ describe("Notebook Editor > Join Step", () => {
setup({
step: createMockNotebookStep({
query: getJoinedQueryWithCustomExpressions(
- () =>
- Lib.expressionClause("value", [10], {
- "base-type": "type/Integer",
- "effective-type": "type/Integer",
- }),
- (findRHSColumn) =>
- Lib.expressionClause(findRHSColumn("PRODUCTS", "ID")),
+ {
+ type: "literal",
+ value: 10,
+ },
+ {
+ type: "column",
+ sourceName: "PRODUCTS",
+ name: "ID",
+ },
),
}),
});
@@ -1362,13 +1379,8 @@ describe("Notebook Editor > Join Step", () => {
setup({
step: createMockNotebookStep({
query: getJoinedQueryWithCustomExpressions(
- (findLHSColumn) =>
- Lib.expressionClause(findLHSColumn("ORDERS", "PRODUCT_ID")),
- () =>
- Lib.expressionClause("value", ["abc"], {
- "base-type": "type/Text",
- "effective-type": "type/Text",
- }),
+ { type: "column", sourceName: "ORDERS", name: "PRODUCT_ID" },
+ { type: "literal", value: "abc" },
),
}),
});
@@ -1382,13 +1394,15 @@ describe("Notebook Editor > Join Step", () => {
setup({
step: createMockNotebookStep({
query: getJoinedQueryWithCustomExpressions(
- (findLHSColumn) =>
- Lib.expressionClause("+", [
- findLHSColumn("ORDERS", "PRODUCT_ID"),
- 1,
- ]),
- (findRHSColumn) =>
- Lib.expressionClause(findRHSColumn("PRODUCTS", "ID")),
+ {
+ type: "operator",
+ operator: "+",
+ args: [
+ { type: "column", sourceName: "ORDERS", name: "PRODUCT_ID" },
+ { type: "literal", value: 1 },
+ ],
+ },
+ { type: "column", sourceName: "PRODUCTS", name: "ID" },
),
}),
});
@@ -1402,10 +1416,19 @@ describe("Notebook Editor > Join Step", () => {
setup({
step: createMockNotebookStep({
query: getJoinedQueryWithCustomExpressions(
- (findLHSColumn) =>
- Lib.expressionClause(findLHSColumn("ORDERS", "PRODUCT_ID")),
- (findRHSColumn) =>
- Lib.expressionClause("+", [findRHSColumn("PRODUCTS", "ID"), 1]),
+ {
+ type: "column",
+ sourceName: "ORDERS",
+ name: "PRODUCT_ID",
+ },
+ {
+ type: "operator",
+ operator: "+",
+ args: [
+ { type: "column", sourceName: "PRODUCTS", name: "ID" },
+ { type: "literal", value: 1 },
+ ],
+ },
),
}),
});
diff --git a/frontend/src/metabase/querying/notebook/components/LimitStep/LimitStep.unit.spec.tsx b/frontend/src/metabase/querying/notebook/components/LimitStep/LimitStep.unit.spec.tsx
index 10643cdb80d..1e3e631c831 100644
--- a/frontend/src/metabase/querying/notebook/components/LimitStep/LimitStep.unit.spec.tsx
+++ b/frontend/src/metabase/querying/notebook/components/LimitStep/LimitStep.unit.spec.tsx
@@ -1,12 +1,16 @@
import { fireEvent, render, screen } from "__support__/ui";
import * as Lib from "metabase-lib";
+import { SAMPLE_PROVIDER } from "metabase-lib/test-helpers";
+import { ORDERS_ID } from "metabase-types/api/mocks/presets";
-import { DEFAULT_QUERY, createMockNotebookStep } from "../../test-utils";
+import { createMockNotebookStep } from "../../test-utils";
import { LimitStep } from "./LimitStep";
const DEFAULT_LIMIT = 10;
-const QUERY_WITH_LIMIT = Lib.limit(DEFAULT_QUERY, 0, DEFAULT_LIMIT);
+const QUERY_WITH_LIMIT = Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [{ source: { type: "table", id: ORDERS_ID }, limit: DEFAULT_LIMIT }],
+});
function setup(step = createMockNotebookStep()) {
const updateQuery = jest.fn();
diff --git a/frontend/src/metabase/querying/notebook/components/Notebook/Notebook.unit.spec.tsx b/frontend/src/metabase/querying/notebook/components/Notebook/Notebook.unit.spec.tsx
index 6dac74a3262..26d56643c0b 100644
--- a/frontend/src/metabase/querying/notebook/components/Notebook/Notebook.unit.spec.tsx
+++ b/frontend/src/metabase/querying/notebook/components/Notebook/Notebook.unit.spec.tsx
@@ -28,10 +28,8 @@ import {
} from "metabase/browse/models/test-utils";
import type { DataPickerValue } from "metabase/common/components/Pickers/DataPicker";
import { checkNotNull } from "metabase/lib/types";
-import {
- SAMPLE_METADATA,
- createQueryWithClauses,
-} from "metabase-lib/test-helpers";
+import * as Lib from "metabase-lib";
+import { SAMPLE_METADATA, SAMPLE_PROVIDER } from "metabase-lib/test-helpers";
import Question from "metabase-lib/v1/Question";
import type { CardType, RecentItem } from "metabase-types/api";
import {
@@ -41,7 +39,10 @@ import {
createMockRecentCollectionItem,
createMockRecentTableItem,
} from "metabase-types/api/mocks";
-import { createSampleDatabase } from "metabase-types/api/mocks/presets";
+import {
+ ORDERS_ID,
+ createSampleDatabase,
+} from "metabase-types/api/mocks/presets";
import { Notebook, type NotebookProps } from "./Notebook";
@@ -191,8 +192,13 @@ function setup({
}
function createSummarizedQuestion(type: CardType) {
- const query = createQueryWithClauses({
- aggregations: [{ operatorName: "count" }],
+ const query = Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
+ {
+ source: { type: "table", id: ORDERS_ID },
+ aggregations: [{ type: "operator", operator: "count", args: [] }],
+ },
+ ],
});
return new Question(createMockCard({ type }), SAMPLE_METADATA).setQuery(
query,
diff --git a/frontend/src/metabase/querying/notebook/components/NotebookStepList/NotebookStepList.unit.spec.tsx b/frontend/src/metabase/querying/notebook/components/NotebookStepList/NotebookStepList.unit.spec.tsx
index 30055fc59f0..b225b1d8948 100644
--- a/frontend/src/metabase/querying/notebook/components/NotebookStepList/NotebookStepList.unit.spec.tsx
+++ b/frontend/src/metabase/querying/notebook/components/NotebookStepList/NotebookStepList.unit.spec.tsx
@@ -3,11 +3,14 @@ import type { ComponentProps } from "react";
import { createMockMetadata } from "__support__/metadata";
import { createMockEntitiesState } from "__support__/store";
import { renderWithProviders, screen } from "__support__/ui";
-import type * as Lib from "metabase-lib";
-import { createQuery, createQueryWithClauses } from "metabase-lib/test-helpers";
+import * as Lib from "metabase-lib";
+import { DEFAULT_TEST_QUERY, SAMPLE_PROVIDER } from "metabase-lib/test-helpers";
import Question from "metabase-lib/v1/Question";
import { createMockCard } from "metabase-types/api/mocks";
-import { createSampleDatabase } from "metabase-types/api/mocks/presets";
+import {
+ ORDERS_ID,
+ createSampleDatabase,
+} from "metabase-types/api/mocks/presets";
import {
createMockQueryBuilderState,
createMockState,
@@ -23,7 +26,10 @@ const metadata = createMockMetadata({
type SetupOpts = Partial<ComponentProps<typeof NotebookStepList>>;
-function setup(opts: SetupOpts = {}, query: Lib.Query = createQuery()) {
+function setup(
+ opts: SetupOpts = {},
+ query: Lib.Query = Lib.createTestQuery(SAMPLE_PROVIDER, DEFAULT_TEST_QUERY),
+) {
const database = createSampleDatabase();
const reportTimezone = "UTC";
const question = new Question(createMockCard(), metadata).setQuery(query);
@@ -54,8 +60,13 @@ function setup(opts: SetupOpts = {}, query: Lib.Query = createQuery()) {
describe("NotebookStepList", () => {
it("renders a list of actions for Summarize step with no breakouts", () => {
- const query = createQueryWithClauses({
- aggregations: [{ operatorName: "count" }],
+ const query = Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
+ {
+ source: { type: "table", id: ORDERS_ID },
+ aggregations: [{ type: "operator", operator: "count", args: [] }],
+ },
+ ],
});
setup({}, query);
diff --git a/frontend/src/metabase/querying/notebook/components/SortStep/SortStep.unit.spec.tsx b/frontend/src/metabase/querying/notebook/components/SortStep/SortStep.unit.spec.tsx
index e42ab90997e..b5d3df9d66f 100644
--- a/frontend/src/metabase/querying/notebook/components/SortStep/SortStep.unit.spec.tsx
+++ b/frontend/src/metabase/querying/notebook/components/SortStep/SortStep.unit.spec.tsx
@@ -7,17 +7,33 @@ import {
screen,
} from "__support__/ui";
import * as Lib from "metabase-lib";
-import { createQuery } from "metabase-lib/test-helpers";
+import { SAMPLE_PROVIDER } from "metabase-lib/test-helpers";
+import { ORDERS_ID } from "metabase-types/api/mocks/presets";
import { createMockNotebookStep } from "../../test-utils";
import { SortStep } from "./SortStep";
function createQueryWithOrderBy(direction: Lib.OrderByDirection = "asc") {
- const initialQuery = createQuery();
- const [column] = Lib.orderableColumns(initialQuery, 0);
- const query = Lib.orderBy(initialQuery, 0, column, direction);
- return { query, columnInfo: Lib.displayInfo(query, 0, column) };
+ const query = Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
+ {
+ source: { type: "table", id: ORDERS_ID },
+ orderBys: [
+ {
+ type: "column",
+ sourceName: "ORDERS",
+ name: "CREATED_AT",
+ direction,
+ },
+ ],
+ },
+ ],
+ });
+ const [orderBy] = Lib.orderBys(query, 0);
+ const columnInfo = Lib.displayInfo(query, 0, orderBy);
+
+ return { query, columnInfo };
}
function setup(step = createMockNotebookStep()) {
diff --git a/frontend/src/metabase/querying/notebook/utils/steps.unit.spec.ts b/frontend/src/metabase/querying/notebook/utils/steps.unit.spec.ts
index 7863f11733f..fcfb399f1c3 100644
--- a/frontend/src/metabase/querying/notebook/utils/steps.unit.spec.ts
+++ b/frontend/src/metabase/querying/notebook/utils/steps.unit.spec.ts
@@ -1,7 +1,7 @@
import { createMockMetadata } from "__support__/metadata";
import { checkNotNull } from "metabase/lib/types";
import * as Lib from "metabase-lib";
-import { createQueryWithClauses } from "metabase-lib/test-helpers";
+import { SAMPLE_PROVIDER } from "metabase-lib/test-helpers";
import Question from "metabase-lib/v1/Question";
import type { StructuredQuery as StructuredQueryObject } from "metabase-types/api";
import {
@@ -287,8 +287,13 @@ describe("filtered and summarized query with post-aggregation filter", () => {
describe("aggregated query without breakout", () => {
it("provides 'join data' and 'custom column' actions", () => {
- const query = createQueryWithClauses({
- aggregations: [{ operatorName: "count" }],
+ const query = Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
+ {
+ source: { type: "table", id: ORDERS_ID },
+ aggregations: [{ type: "operator", operator: "count", args: [] }],
+ },
+ ],
});
const question = Question.create({
diff --git a/frontend/src/metabase/querying/parameters/utils/query.unit.spec.ts b/frontend/src/metabase/querying/parameters/utils/query.unit.spec.ts
index 275bab5cd4c..c93e13b6eed 100644
--- a/frontend/src/metabase/querying/parameters/utils/query.unit.spec.ts
+++ b/frontend/src/metabase/querying/parameters/utils/query.unit.spec.ts
@@ -2,9 +2,10 @@ import { createMockMetadata } from "__support__/metadata";
import { isNotNull } from "metabase/lib/types";
import * as Lib from "metabase-lib";
import {
+ DEFAULT_TEST_QUERY,
+ SAMPLE_PROVIDER,
columnFinder,
- createQuery,
- createQueryWithClauses,
+ createMetadataProvider,
} from "metabase-lib/test-helpers";
import type {
ParameterTarget,
@@ -58,9 +59,11 @@ const METADATA = createMockMetadata({
],
});
+const PROVIDER = createMetadataProvider({ metadata: METADATA });
+
describe("applyParameter", () => {
describe("filter parameters", () => {
- const query = createQuery({ metadata: METADATA });
+ const query = Lib.createTestQuery(PROVIDER, DEFAULT_TEST_QUERY);
const stageIndex = 0;
const columns = Lib.filterableColumns(query, stageIndex);
const findColumn = columnFinder(query, columns);
@@ -347,7 +350,9 @@ describe("applyParameter", () => {
);
it("should ignore parameters with stage index out of range (metabase#55678)", () => {
- const query = Lib.appendStage(createQuery());
+ const query = Lib.appendStage(
+ Lib.createTestQuery(SAMPLE_PROVIDER, DEFAULT_TEST_QUERY),
+ );
const stageIndex = 1;
const column = Lib.filterableColumns(query, stageIndex)[0];
const columnRef = Lib.legacyRef(query, stageIndex, column);
@@ -368,12 +373,18 @@ describe("applyParameter", () => {
});
describe("temporal unit parameters", () => {
- const query = createQueryWithClauses({
- breakouts: [
+ const query = Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
{
- tableName: "ORDERS",
- columnName: "CREATED_AT",
- temporalBucketName: "Month",
+ source: { type: "table", id: ORDERS_ID },
+ breakouts: [
+ {
+ type: "column",
+ name: "CREATED_AT",
+ sourceName: "ORDERS",
+ unit: "month",
+ },
+ ],
},
],
});
diff --git a/frontend/src/metabase/querying/viz-settings/utils/sync-viz-settings.unit.spec.tsx b/frontend/src/metabase/querying/viz-settings/utils/sync-viz-settings.unit.spec.tsx
index a005de90539..f41e402b2a7 100644
--- a/frontend/src/metabase/querying/viz-settings/utils/sync-viz-settings.unit.spec.tsx
+++ b/frontend/src/metabase/querying/viz-settings/utils/sync-viz-settings.unit.spec.tsx
@@ -1,10 +1,5 @@
import * as Lib from "metabase-lib";
-import {
- SAMPLE_METADATA,
- columnFinder,
- createQuery,
- createQueryWithClauses,
-} from "metabase-lib/test-helpers";
+import { SAMPLE_METADATA, SAMPLE_PROVIDER } from "metabase-lib/test-helpers";
import type { Series } from "metabase-types/api";
import {
createMockCard,
@@ -13,7 +8,7 @@ import {
createMockTableColumnOrderSetting,
createMockVisualizationSettings,
} from "metabase-types/api/mocks";
-import { SAMPLE_DB_ID } from "metabase-types/api/mocks/presets";
+import { ORDERS_ID, SAMPLE_DB_ID } from "metabase-types/api/mocks/presets";
import {
type ColumnInfo,
@@ -434,19 +429,31 @@ describe("syncVizSettings", () => {
describe("syncVizSettingsWithQuery", () => {
describe("table.columns", () => {
it("should handle adding new columns with column.name changes", () => {
- const baseQuery = createQuery();
- const stageIndex = -1;
- const availableColumns = Lib.visibleColumns(baseQuery, stageIndex);
- const findColumn = columnFinder(baseQuery, availableColumns);
- const oldQuery = Lib.withFields(baseQuery, stageIndex, [
- findColumn("ORDERS", "ID"),
- findColumn("PEOPLE", "ID"),
- ]);
- const newQuery = Lib.withFields(baseQuery, stageIndex, [
- findColumn("ORDERS", "ID"),
- findColumn("PRODUCTS", "ID"),
- findColumn("PEOPLE", "ID"),
- ]);
+ const oldQuery = Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
+ {
+ source: { type: "table", id: ORDERS_ID },
+ fields: [
+ { type: "column", name: "ID", sourceName: "ORDERS" },
+ { type: "column", name: "ID", sourceName: "PEOPLE" },
+ ],
+ },
+ ],
+ });
+
+ const newQuery = Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
+ {
+ source: { type: "table", id: ORDERS_ID },
+ fields: [
+ { type: "column", name: "ID", sourceName: "ORDERS" },
+ { type: "column", name: "ID", sourceName: "PRODUCTS" },
+ { type: "column", name: "ID", sourceName: "PEOPLE" },
+ ],
+ },
+ ],
+ });
+
const oldSettings = createMockVisualizationSettings({
"table.columns": [
createMockTableColumnOrderSetting({
@@ -477,18 +484,46 @@ describe("syncVizSettingsWithQuery", () => {
describe("graph.metrics", () => {
it("should handle adding new columns", () => {
- const oldQuery = createQueryWithClauses({
- aggregations: [
- { operatorName: "sum", tableName: "ORDERS", columnName: "TOTAL" },
+ const oldQuery = Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
+ {
+ source: { type: "table", id: ORDERS_ID },
+ aggregations: [
+ {
+ type: "operator",
+ operator: "sum",
+ args: [{ type: "column", name: "TOTAL", sourceName: "ORDERS" }],
+ },
+ ],
+ breakouts: [
+ { type: "column", name: "CREATED_AT", sourceName: "ORDERS" },
+ ],
+ },
],
- breakouts: [{ tableName: "ORDERS", columnName: "CREATED_AT" }],
});
- const newQuery = createQueryWithClauses({
- aggregations: [
- { operatorName: "sum", tableName: "ORDERS", columnName: "TOTAL" },
- { operatorName: "sum", tableName: "ORDERS", columnName: "SUBTOTAL" },
+ const newQuery = Lib.createTestQuery(SAMPLE_PROVIDER, {
+ stages: [
+ {
+ source: { type: "table", id: ORDERS_ID },
+ aggregations: [
+ {
+ type: "operator",
+ operator: "sum",
+ args: [{ type: "column", name: "TOTAL", sourceName: "ORDERS" }],
+ },
+ {
+ type: "operator",
+ operator: "sum",
+ args: [
+ { type: "column", name: "SUBTOTAL", sourceName: "ORDERS" },
+ ],
+ },
+ ],
+ breakouts: [
+ { type: "column", name: "CREATED_AT", sourceName: "ORDERS" },
+ ],
+ },
],
- breakouts: [{ tableName: "ORDERS", columnName: "CREATED_AT" }],
});
const oldSettings = createMockVisualizationSettings({
"graph.metrics": ["sum"],
diff --git a/src/metabase/lib/query/test_spec.cljc b/src/metabase/lib/query/test_spec.cljc
index 37a1a8742a2..475872eb12e 100644
--- a/src/metabase/lib/query/test_spec.cljc
+++ b/src/metabase/lib/query/test_spec.cljc
@@ -59,7 +59,9 @@
(case (count columns)
0 (throw (ex-info "No column found" {:columns available-columns, :column-spec column-spec}))
1 (first columns)
- (throw (ex-info "Multiple columns found" {:columns columns, :column-spec column-spec})))))
+ (if (:index column-spec)
+ (get columns (:index column-spec))
+ (throw (ex-info "Multiple columns found" {:columns columns, :column-spec column-spec}))))))
(mu/defn- append-fields :- ::lib.schema/query
[query :- ::lib.schema/query
@@ -97,11 +99,15 @@
(mu/defn- matches-binning? :- :boolean
[strategy :- ::lib.schema.binning/strategy
- value :- [:or ::lib.schema.binning/num-bins ::lib.schema.binning/bin-width]
+ value :- [:or ::lib.schema.binning/num-bins ::lib.schema.binning/bin-width ::lib.schema.test-spec/test-auto-bin-spec]
{:keys [mbql]} :- ::lib.schema.binning/binning-option]
- (and
- (= strategy (:strategy mbql))
- (== value (strategy mbql))))
+ (or
+ (and
+ (= :default (:strategy mbql))
+ (= value :auto))
+ (and
+ (= strategy (:strategy mbql))
+ (== value (strategy mbql)))))
(mu/defn- find-binning-strategy :- ::lib.schema.binning/binning-option
[query :- ::lib.schema/query
diff --git a/src/metabase/lib/schema/test_spec.cljc b/src/metabase/lib/schema/test_spec.cljc
index 53aa193d30d..f63b62fd371 100644
--- a/src/metabase/lib/schema/test_spec.cljc
+++ b/src/metabase/lib/schema/test_spec.cljc
@@ -32,19 +32,23 @@
[:type [:= {:decode/normalize lib.schema.common/normalize-keyword} :column]]
[:name string?]
[:source-name {:optional true} [:maybe string?]]
- [:display-name {:optional true} [:maybe string?]]])
+ [:display-name {:optional true} [:maybe string?]]
+ [:index {:optional true} [:maybe pos-int?]]])
(mr/def ::test-temporal-bucket-spec
[:map
[:unit {:optional true} [:maybe ::lib.schema.temporal-bucketing/unit]]])
+(mr/def ::test-auto-bin-spec
+ [:= {:decode/normalize lib.schema.common/normalize-keyword} :auto])
+
(mr/def ::test-bin-count-bucket-spec
[:map
- [:bins {:optional true} [:maybe ::lib.schema.binning/num-bins]]])
+ [:bins {:optional true} [:maybe [:or ::lib.schema.binning/num-bins ::test-auto-bin-spec]]]])
(mr/def ::test-bin-width-bucket-spec
[:map
- [:bin-width {:optional true} [:maybe ::lib.schema.binning/bin-width]]])
+ [:bin-width {:optional true} [:maybe [:or ::lib.schema.binning/bin-width ::test-auto-bin-spec]]]])
(mr/def ::test-column-with-binning-spec
[:merge