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
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 {
DEFAULT_TEST_QUERY,
SAMPLE_PROVIDER,
columnFinder,
createMetadataProvider,
} from "./test-helpers";
describe("order by", () => {
describe("orderableColumns", () => {
const query = Lib.createTestQuery(SAMPLE_PROVIDER, {
stages: [
{
source: {
type: "table",
id: ORDERS_ID,
},
},
],
});
const findOrderableColumn = columnFinder(
query,
Lib.orderableColumns(query, 0),
);
it("returns metadata for columns in the source table", () => {
const ordersID = findOrderableColumn("ORDERS", "ID");
expect(Lib.displayInfo(query, 0, ordersID)).toEqual(
expect.objectContaining({
name: "ID",
displayName: "ID",
longDisplayName: "ID",
effectiveType: "type/BigInteger",
semanticType: "type/PK",
isCalculated: false,
isFromJoin: false,
isFromPreviousStage: false,
isImplicitlyJoinable: false,
table: {
name: "ORDERS",
displayName: "Orders",
longDisplayName: "Orders",
isSourceTable: true,
schema: "1:PUBLIC",
visibilityType: null,
},
}),
);
});
it("returns metadata for columns in implicitly joinable tables", () => {
const productsTitle = findOrderableColumn("PRODUCTS", "TITLE");
expect(Lib.displayInfo(query, 0, productsTitle)).toEqual(
expect.objectContaining({
name: "TITLE",
displayName: "Title",
longDisplayName: "Product → Title",
effectiveType: "type/Text",
semanticType: "type/Title",
isCalculated: false,
isFromJoin: false,
isFromPreviousStage: false,
isImplicitlyJoinable: true,
table: {
name: "PRODUCTS",
displayName: "Products",
longDisplayName: "Products",
isSourceTable: false,
schema: "1:PUBLIC",
visibilityType: null,
},
}),
);
});
it("returns metadata for columns in source question/model", () => {
const field = createProductsTitleField();
const card = createMockCard({
name: "Product Model",
result_metadata: [field],
});
const metadata = createMockMetadata({
databases: [createSampleDatabase()],
questions: [card],
});
const provider = createMetadataProvider({
databaseId: SAMPLE_DB_ID,
metadata,
});
const query = Lib.createTestQuery(provider, {
stages: [
{
source: {
type: "card",
id: card.id,
},
},
],
});
const columns = Lib.orderableColumns(query, 0);
const productsTitle = columns.find(
(columnMetadata: Lib.ColumnMetadata) => {
const displayInfo = Lib.displayInfo(query, 0, columnMetadata);
return (
displayInfo.displayName === "Title" &&
displayInfo.table?.displayName === "Product Model"
);
},
);
expect(
// Unjustified type cast. FIXME
Lib.displayInfo(query, 0, productsTitle as Lib.ColumnMetadata),
).toEqual(
expect.objectContaining({
name: field.name,
displayName: field.display_name,
effectiveType: field.base_type,
table: { name: "Product Model", displayName: "Product Model" },
}),
);
});
it("should preserve order-by positions between v1-v2 roundtrip", () => {
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);
const nextTaxColumn = columnFinder(nextQuery, nextQueryColumns)(
"ORDERS",
"TAX",
);
expect(Lib.displayInfo(nextQuery, 0, nextTaxColumn).orderByPosition).toBe(
0,
);
const roundtripQuery = Lib.fromJsQuery(
SAMPLE_PROVIDER,
Lib.toJsQuery(nextQuery),
);
const roundtripQueryColumns = Lib.orderableColumns(roundtripQuery, 0);
const roundtripTaxColumn = columnFinder(
roundtripQuery,
roundtripQueryColumns,
)("ORDERS", "TAX");
expect(
Lib.displayInfo(roundtripQuery, 0, roundtripTaxColumn).orderByPosition,
).toBe(0);
});
});
describe("add order by", () => {
const query = Lib.createTestQuery(SAMPLE_PROVIDER, DEFAULT_TEST_QUERY);
const findOrderableColumn = columnFinder(
query,
Lib.orderableColumns(query, 0),
);
it("should handle no order by clauses", () => {
expect(Lib.orderBys(query, 0)).toHaveLength(0);
});
it("should update the query", () => {
const productTitle = findOrderableColumn("PRODUCTS", "TITLE");
const nextQuery = Lib.orderBy(query, 0, productTitle);
const orderBys = Lib.orderBys(nextQuery, 0);
expect(orderBys).toHaveLength(1);
const displayInfo = Lib.displayInfo(nextQuery, 0, orderBys[0]);
expect(displayInfo.displayName).toBe("Title");
expect(displayInfo.direction).toBe("asc");
});
});
describe("replace order by", () => {
const query = Lib.createTestQuery(SAMPLE_PROVIDER, DEFAULT_TEST_QUERY);
const findOrderableColumn = columnFinder(
query,
Lib.orderableColumns(query, 0),
);
it("should update the query", () => {
const productTitle = findOrderableColumn("PRODUCTS", "TITLE");
const productCategory = findOrderableColumn("PRODUCTS", "CATEGORY");
const orderedQuery = Lib.orderBy(query, 0, productTitle);
const orderBys = Lib.orderBys(orderedQuery, 0);
expect(orderBys).toHaveLength(1);
const nextQuery = Lib.replaceClause(
orderedQuery,
0,
orderBys[0],
Lib.orderByClause(productCategory, "desc"),
);
const nextOrderBys = Lib.orderBys(nextQuery, 0);
const displayInfo = Lib.displayInfo(nextQuery, 0, nextOrderBys[0]);
expect(displayInfo.displayName).toBe("Category");
expect(displayInfo.direction).toBe("desc");
expect(orderBys[0]).not.toEqual(nextOrderBys[0]);
});
});
describe("remove order by", () => {
const query = Lib.createTestQuery(SAMPLE_PROVIDER, DEFAULT_TEST_QUERY);
const findOrderableColumn = columnFinder(
query,
Lib.orderableColumns(query, 0),
);
it("should update the query", () => {
const productTitle = findOrderableColumn("PRODUCTS", "TITLE");
const orderedQuery = Lib.orderBy(query, 0, productTitle);
const orderBys = Lib.orderBys(orderedQuery, 0);
expect(orderBys).toHaveLength(1);
const nextQuery = Lib.removeClause(orderedQuery, 0, orderBys[0]);
expect(Lib.orderBys(nextQuery, 0)).toHaveLength(0);
});
});
});