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