@mwater/visualization 5.0.0

package/test/widgets/charts/pivot/PivotChartQueryBuilderTests.ts

@@ -0,0 +1,359 @@
+// TODO: This file was created by bulk-decaffeinate.
+// Sanity-check the conversion and remove this comment.
+import { assert } from "chai"
+import * as fixtures from "../../../fixtures"
+import _ from "lodash"
+import PivotChartQueryBuilder from "../../../../src/widgets/charts/pivot/PivotChartQueryBuilder"
+import canonical from "canonical-json"
+
+function compare(actual: any, expected: any) {
+  return assert.equal(
+    canonical(actual),
+    canonical(expected),
+    "\n" + canonical(actual) + "\n" + canonical(expected) + "\n"
+  )
+}
+
+describe("PivotChartQueryBuilder", function () {
+  before(function () {
+    this.qb = new PivotChartQueryBuilder({ schema: fixtures.simpleSchema() })
+    this.exprBoolean = { type: "field", table: "t1", column: "boolean" }
+    this.exprNumber = { type: "field", table: "t1", column: "number" }
+    this.exprText = { type: "field", table: "t1", column: "text" }
+    this.exprEnum = { type: "field", table: "t1", column: "enum" }
+    this.exprNumberSum = {
+      type: "op",
+      op: "sum",
+      table: "t1",
+      exprs: [{ type: "field", table: "t1", column: "number" }]
+    }
+
+    this.axisNumber = { expr: this.exprNumber }
+    this.axisNumberSum = { expr: this.exprNumberSum }
+    this.axisCount = { expr: { type: "op", op: "count", table: "t1", exprs: [] } }
+    this.axisEnum = { expr: this.exprEnum }
+    return (this.axisText = { expr: this.exprText })
+  })
+
+  it("creates single query", function () {
+    const design = {
+      table: "t1",
+      rows: [{ id: "r1", valueAxis: this.axisEnum }],
+      columns: [{ id: "c1", valueAxis: this.axisText }],
+      intersections: {
+        "r1:c1": {
+          valueAxis: this.axisNumberSum
+        }
+      }
+    }
+
+    const queries = this.qb.createQueries(design)
+    assert.equal(_.values(queries).length, 1, "Should have single query")
+
+    const query = queries["r1:c1"]
+    return compare(query, {
+      type: "query",
+      selects: [
+        { type: "select", expr: { type: "field", tableAlias: "main", column: "enum" }, alias: "r0" },
+        { type: "select", expr: { type: "field", tableAlias: "main", column: "text" }, alias: "c0" },
+        {
+          type: "select",
+          expr: { type: "op", op: "sum", exprs: [{ type: "field", tableAlias: "main", column: "number" }] },
+          alias: "value"
+        }
+      ],
+      from: { type: "table", table: "t1", alias: "main" },
+      limit: 10000,
+      groupBy: [1, 2]
+    })
+  })
+
+  it("creates nested query")
+
+  it("adds filters query", function () {
+    const design = {
+      table: "t1",
+      rows: [{ id: "r1", valueAxis: this.axisEnum, filter: this.exprBoolean }],
+      columns: [{ id: "c1", valueAxis: this.axisText }],
+      intersections: {
+        "r1:c1": {
+          valueAxis: this.axisNumberSum
+        }
+      }
+    }
+
+    const queries = this.qb.createQueries(design)
+    assert.equal(_.values(queries).length, 1, "Should have single query")
+
+    const query = queries["r1:c1"]
+    return compare(query, {
+      type: "query",
+      selects: [
+        { type: "select", expr: { type: "field", tableAlias: "main", column: "enum" }, alias: "r0" },
+        { type: "select", expr: { type: "field", tableAlias: "main", column: "text" }, alias: "c0" },
+        {
+          type: "select",
+          expr: { type: "op", op: "sum", exprs: [{ type: "field", tableAlias: "main", column: "number" }] },
+          alias: "value"
+        }
+      ],
+      from: { type: "table", table: "t1", alias: "main" },
+      where: { type: "field", tableAlias: "main", column: "boolean" },
+      limit: 10000,
+      groupBy: [1, 2]
+    })
+  })
+
+  it("adds double filtered query", function () {
+    const design = {
+      table: "t1",
+      rows: [{ id: "r1", valueAxis: this.axisEnum, filter: this.exprBoolean }],
+      columns: [{ id: "c1", valueAxis: this.axisText }],
+      intersections: {
+        "r1:c1": {
+          valueAxis: this.axisNumberSum,
+          filter: { type: "literal", valueType: "boolean", value: true }
+        }
+      }
+    }
+
+    const queries = this.qb.createQueries(design)
+    assert.equal(_.values(queries).length, 1, "Should have single query")
+
+    const query = queries["r1:c1"]
+    return compare(query, {
+      type: "query",
+      selects: [
+        { type: "select", expr: { type: "field", tableAlias: "main", column: "enum" }, alias: "r0" },
+        { type: "select", expr: { type: "field", tableAlias: "main", column: "text" }, alias: "c0" },
+        {
+          type: "select",
+          expr: { type: "op", op: "sum", exprs: [{ type: "field", tableAlias: "main", column: "number" }] },
+          alias: "value"
+        }
+      ],
+      from: { type: "table", table: "t1", alias: "main" },
+      where: {
+        type: "op",
+        op: "and",
+        exprs: [
+          { type: "field", tableAlias: "main", column: "boolean" },
+          { type: "literal", value: true }
+        ]
+      },
+      limit: 10000,
+      groupBy: [1, 2]
+    })
+  })
+
+  it("adds background color axis", function () {
+    const design = {
+      table: "t1",
+      rows: [{ id: "r1", valueAxis: this.axisEnum }],
+      columns: [{ id: "c1", valueAxis: this.axisText }],
+      intersections: {
+        "r1:c1": {
+          valueAxis: this.axisNumberSum,
+          backgroundColorAxis: this.axisCount
+        }
+      }
+    }
+
+    const queries = this.qb.createQueries(design)
+    assert.equal(_.values(queries).length, 1, "Should have single query")
+
+    const query = queries["r1:c1"]
+    return compare(query, {
+      type: "query",
+      selects: [
+        { type: "select", expr: { type: "field", tableAlias: "main", column: "enum" }, alias: "r0" },
+        { type: "select", expr: { type: "field", tableAlias: "main", column: "text" }, alias: "c0" },
+        {
+          type: "select",
+          expr: { type: "op", op: "sum", exprs: [{ type: "field", tableAlias: "main", column: "number" }] },
+          alias: "value"
+        },
+        { type: "select", expr: { type: "op", op: "count", exprs: [] }, alias: "bc" }
+      ],
+      from: { type: "table", table: "t1", alias: "main" },
+      limit: 10000,
+      groupBy: [1, 2]
+    })
+  })
+
+  it("adds background color conditions", function () {
+    const design = {
+      table: "t1",
+      rows: [{ id: "r1", valueAxis: this.axisEnum }],
+      columns: [{ id: "c1", valueAxis: this.axisText }],
+      intersections: {
+        "r1:c1": {
+          valueAxis: this.axisNumberSum,
+          backgroundColorConditions: [
+            {
+              condition: {
+                type: "op",
+                op: ">",
+                table: "t1",
+                exprs: [this.exprNumberSum, { type: "literal", valueType: "number", value: 5 }]
+              },
+              color: "red"
+            }
+          ]
+        }
+      }
+    }
+
+    const queries = this.qb.createQueries(design)
+    assert.equal(_.values(queries).length, 1, "Should have single query")
+
+    const query = queries["r1:c1"]
+    return compare(query, {
+      type: "query",
+      selects: [
+        { type: "select", expr: { type: "field", tableAlias: "main", column: "enum" }, alias: "r0" },
+        { type: "select", expr: { type: "field", tableAlias: "main", column: "text" }, alias: "c0" },
+        {
+          type: "select",
+          expr: { type: "op", op: "sum", exprs: [{ type: "field", tableAlias: "main", column: "number" }] },
+          alias: "value"
+        },
+        {
+          type: "select",
+          expr: {
+            type: "op",
+            op: ">",
+            exprs: [
+              { type: "op", op: "sum", exprs: [{ type: "field", tableAlias: "main", column: "number" }] },
+              { type: "literal", value: 5 }
+            ]
+          },
+          alias: "bcc0"
+        }
+      ],
+      from: { type: "table", table: "t1", alias: "main" },
+      limit: 10000,
+      groupBy: [1, 2]
+    })
+  })
+
+  it("creates ordered single query", function () {
+    const design = {
+      table: "t1",
+      rows: [{ id: "r1", valueAxis: this.axisEnum, orderExpr: this.exprNumberSum, orderDir: "desc" }],
+      columns: [{ id: "c1", valueAxis: this.axisText }],
+      intersections: {
+        "r1:c1": {
+          valueAxis: this.axisNumberSum
+        }
+      }
+    }
+
+    const queries = this.qb.createQueries(design)
+
+    const query = queries["r1"]
+    return compare(query, {
+      type: "query",
+      selects: [{ type: "select", expr: { type: "field", tableAlias: "main", column: "enum" }, alias: "value" }],
+      from: { type: "table", table: "t1", alias: "main" },
+      where: { type: "op", op: "or", exprs: [{ type: "literal", value: true }] },
+      groupBy: [1],
+      orderBy: [
+        {
+          expr: { type: "op", op: "sum", exprs: [{ type: "field", tableAlias: "main", column: "number" }] },
+          direction: "desc"
+        }
+      ]
+    })
+  })
+
+  it("creates ordered single query which includes filters", function () {
+    const design = {
+      table: "t1",
+      rows: [
+        {
+          id: "r1",
+          valueAxis: this.axisEnum,
+          orderExpr: this.exprNumberSum,
+          orderDir: "desc",
+          filter: this.exprBoolean
+        }
+      ],
+      columns: [{ id: "c1", valueAxis: this.axisText }],
+      intersections: {
+        "r1:c1": {
+          valueAxis: this.axisNumberSum,
+          filter: { type: "literal", valueType: "boolean", value: true }
+        }
+      }
+    }
+
+    const queries = this.qb.createQueries(design)
+
+    const query = queries["r1"]
+    return compare(query, {
+      type: "query",
+      selects: [{ type: "select", expr: { type: "field", tableAlias: "main", column: "enum" }, alias: "value" }],
+      from: { type: "table", table: "t1", alias: "main" },
+      where: {
+        type: "op",
+        op: "and",
+        exprs: [
+          { type: "field", tableAlias: "main", column: "boolean" },
+          {
+            type: "op",
+            op: "or",
+            exprs: [{ type: "literal", value: true }]
+          }
+        ]
+      },
+      groupBy: [1],
+      orderBy: [
+        {
+          expr: { type: "op", op: "sum", exprs: [{ type: "field", tableAlias: "main", column: "number" }] },
+          direction: "desc"
+        }
+      ]
+    })
+  })
+
+  return it("creates ordered single query with extraFilters", function () {
+    const design = {
+      table: "t1",
+      rows: [{ id: "r1", valueAxis: this.axisEnum, orderExpr: this.exprNumberSum, orderDir: "desc" }],
+      columns: [{ id: "c1", valueAxis: this.axisText }],
+      intersections: {
+        "r1:c1": {
+          valueAxis: this.axisNumberSum
+        }
+      }
+    }
+
+    const queries = this.qb.createQueries(design, [
+      { table: "t1", jsonql: { type: "literal", value: false } },
+      { table: "t2", jsonql: { type: "literal", value: true } }
+    ])
+
+    const query = queries["r1"]
+    return compare(query, {
+      type: "query",
+      selects: [{ type: "select", expr: { type: "field", tableAlias: "main", column: "enum" }, alias: "value" }],
+      from: { type: "table", table: "t1", alias: "main" },
+      where: {
+        type: "op",
+        op: "and",
+        exprs: [
+          { type: "op", op: "or", exprs: [{ type: "literal", value: true }] },
+          { type: "literal", value: false }
+        ]
+      },
+      groupBy: [1],
+      orderBy: [
+        {
+          expr: { type: "op", op: "sum", exprs: [{ type: "field", tableAlias: "main", column: "number" }] },
+          direction: "desc"
+        }
+      ]
+    })
+  })
+})

package/test/widgets/charts/pivot/PivotChartTests.ts

@@ -0,0 +1,64 @@
+// TODO: This file was created by bulk-decaffeinate.
+// Sanity-check the conversion and remove this comment.
+import { assert } from "chai"
+import * as fixtures from "../../../fixtures"
+import _ from "lodash"
+import PivotChart from "../../../../src/widgets/charts/pivot/PivotChart"
+import canonical from "canonical-json"
+
+function compare(actual: any, expected: any) {
+  return assert.equal(
+    canonical(actual),
+    canonical(expected),
+    "\n" + canonical(actual) + "\n" + canonical(expected) + "\n"
+  )
+}
+
+describe("PivotChart", function () {
+  before(function () {
+    this.schema = fixtures.simpleSchema()
+
+    this.pc = new PivotChart()
+    this.exprNumber = { type: "field", table: "t1", column: "number" }
+    this.exprText = { type: "field", table: "t1", column: "text" }
+    this.exprEnum = { type: "field", table: "t1", column: "enum" }
+
+    this.axisNumber = { expr: this.exprNumber }
+    this.axisCount = { expr: { type: "op", op: "count", table: "t1", exprs: [] } }
+    this.axisNumberSum = { expr: { type: "op", op: "sum", table: "t1", exprs: [this.exprNumber] } }
+    this.axisEnum = { expr: this.exprEnum }
+    return (this.axisText = { expr: this.exprText })
+  })
+
+  return describe("cleanDesign", function () {
+    it("adds missing intersections as blank", function () {
+      let design = {
+        table: "t1",
+        rows: [{ id: "row1" }],
+        columns: [{ id: "col1" }]
+      }
+
+      design = this.pc.cleanDesign(design, this.schema)
+      return compare(design.intersections, {
+        "row1:col1": {}
+      })
+    })
+
+    return it("removes extra intersections", function () {
+      let design = {
+        table: "t1",
+        rows: [{ id: "row1" }],
+        columns: [{ id: "col1" }],
+        intersections: {
+          "row1:col1": { valueAxis: this.axisNumberSum },
+          "rowX:col1": { valueAxis: this.axisNumberSum }
+        }
+      }
+
+      design = this.pc.cleanDesign(design, this.schema)
+      return compare(design.intersections, {
+        "row1:col1": { valueAxis: this.axisNumberSum }
+      })
+    })
+  })
+})

package/test/widgets/charts/pivot/PivotChartUtilsTests.ts

@@ -0,0 +1,184 @@
+// TODO: This file was created by bulk-decaffeinate.
+// Sanity-check the conversion and remove this comment.
+import { assert } from "chai"
+import _ from "lodash"
+import * as PivotChartUtils from "../../../../src/widgets/charts/pivot/PivotChartUtils"
+import canonical from "canonical-json"
+
+function compare(actual: any, expected: any) {
+  return assert.equal(
+    canonical(actual),
+    canonical(expected),
+    "\n" + canonical(actual) + "\n" + canonical(expected) + "\n"
+  )
+}
+
+describe("PivotChartUtils", function () {
+  describe("getSegmentPaths", function () {
+    it("gets simple paths", function () {
+      const segments = [{ id: "a" }, { id: "b" }]
+      return compare(PivotChartUtils.getSegmentPaths(segments), [[{ id: "a" }], [{ id: "b" }]])
+    })
+
+    return it("gets nested paths", function () {
+      const segments = [{ id: "a", children: [{ id: "c" }, { id: "d" }] }, { id: "b" }]
+      return compare(PivotChartUtils.getSegmentPaths(segments), [
+        [segments[0], { id: "c" }],
+        [segments[0], { id: "d" }],
+        [segments[1]]
+      ])
+    })
+  })
+
+  describe("getAllSegments", () =>
+    it("gets nested paths", function () {
+      const segments = [{ id: "a", children: [{ id: "c" }, { id: "d" }] }, { id: "b" }]
+      return compare(PivotChartUtils.getAllSegments(segments), [segments[0], { id: "c" }, { id: "d" }, segments[1]])
+    }))
+
+  describe("findSegment", function () {
+    it("finds nested", function () {
+      const segments = [{ id: "a", children: [{ id: "c" }, { id: "d" }] }, { id: "b" }]
+      return compare(PivotChartUtils.findSegment(segments, "c"), { id: "c" })
+    })
+
+    return it("finds null if not found", function () {
+      const segments = [{ id: "a", children: [{ id: "c" }, { id: "d" }] }, { id: "b" }]
+      return assert(!PivotChartUtils.findSegment(segments, "x"))
+    })
+  })
+
+  describe("canSummarizeSegment", function () {
+    it("is false if first", function () {
+      const segments = [{ id: "a" }, { id: "b" }]
+      return assert.isFalse(PivotChartUtils.canSummarizeSegment(segments, "a"))
+    })
+
+    it("is false if before is label only", function () {
+      const segments = [{ id: "a", label: "A" }, { id: "b" }]
+      return assert.isFalse(PivotChartUtils.canSummarizeSegment(segments, "b"))
+    })
+
+    it("is true if before has value axis", function () {
+      const segments = [
+        { id: "a", label: "A", valueAxis: { expr: { type: "field", table: "t1", column: "number" } } },
+        { id: "b" }
+      ]
+      return assert.isTrue(PivotChartUtils.canSummarizeSegment(segments, "b"))
+    })
+
+    it("is false if before has children", function () {
+      const segments = [
+        {
+          id: "a",
+          label: "A",
+          valueAxis: { expr: { type: "field", table: "t1", column: "number" } },
+          children: [{ id: "z" }]
+        },
+        { id: "b" }
+      ]
+      return assert.isFalse(PivotChartUtils.canSummarizeSegment(segments, "b"))
+    })
+
+    return it("works on nested", function () {
+      const segments = [
+        {
+          id: "a",
+          label: "A",
+          children: [{ id: "b", valueAxis: { expr: { type: "field", table: "t1", column: "number" } } }, { id: "c" }]
+        }
+      ]
+      return assert.isTrue(PivotChartUtils.canSummarizeSegment(segments, "c"))
+    })
+  })
+
+  describe("summarizeSegment", () =>
+    it("creates intersections", function () {
+      // Intersection axes
+      const sum1 = { expr: { type: "op", op: "sum", exprs: [{ type: "field", table: "t1", column: "number1" }] } }
+      const sum2 = { expr: { type: "op", op: "sum", exprs: [{ type: "field", table: "t1", column: "number2" }] } }
+
+      const design = {
+        rows: [
+          { id: "r1", label: "A", valueAxis: { expr: { type: "field", table: "t1", column: "enum" } } },
+          { id: "r2" }
+        ],
+        columns: [
+          { id: "c1", label: "C1" },
+          { id: "c2", label: "C2" }
+        ],
+        intersections: {
+          "r1:c1": { valueAxis: sum1 },
+          "r1:c2": { valueAxis: sum2 },
+          "r2:c1": {},
+          "r2:c2": {}
+        }
+      }
+
+      const newDesign = PivotChartUtils.summarizeSegment(design, "r2", "Total")
+
+      return compare(newDesign, {
+        rows: [
+          { id: "r1", label: "A", valueAxis: { expr: { type: "field", table: "t1", column: "enum" } } },
+          { id: "r2", label: "Total" }
+        ],
+        columns: [
+          { id: "c1", label: "C1" },
+          { id: "c2", label: "C2" }
+        ],
+        intersections: {
+          "r1:c1": { valueAxis: sum1 },
+          "r1:c2": { valueAxis: sum2 },
+          "r2:c1": { valueAxis: sum1 },
+          "r2:c2": { valueAxis: sum2 }
+        }
+      })
+    }))
+
+  describe("replaceSegment", () =>
+    it("replaces nested", function () {
+      const segments = [{ id: "a", children: [{ id: "c" }, { id: "d" }] }, { id: "b" }]
+      return compare(PivotChartUtils.replaceSegment(segments, { id: "c", x: 1 }), [
+        { id: "a", children: [{ id: "c", x: 1 }, { id: "d" }] },
+        { id: "b" }
+      ])
+    }))
+
+  describe("removeSegment", () =>
+    it("removes nested", function () {
+      const segments = [{ id: "a", children: [{ id: "c" }, { id: "d" }] }, { id: "b" }]
+      return compare(PivotChartUtils.removeSegment(segments, "c"), [{ id: "a", children: [{ id: "d" }] }, { id: "b" }])
+    }))
+
+  describe("insertBeforeSegment", () =>
+    it("handles nested", function () {
+      let segments = [{ id: "a", children: [{ id: "c" }, { id: "d" }] }, { id: "b" }]
+      segments = PivotChartUtils.insertBeforeSegment(segments, "c")
+      assert.equal(segments[0].children.length, 3)
+      return assert.equal(segments[0].children[1].id, "c")
+    }))
+
+  describe("insertAfterSegment", function () {
+    it("handles simple", function () {
+      let segments = [{ id: "a" }, { id: "b" }, { id: "c" }]
+      segments = PivotChartUtils.insertAfterSegment(segments, "b")
+      assert.equal(segments.length, 4)
+      return assert.equal(segments[3].id, "c")
+    })
+
+    return it("handles nested", function () {
+      let segments = [{ id: "a", children: [{ id: "c" }, { id: "d" }] }, { id: "b" }]
+      segments = PivotChartUtils.insertAfterSegment(segments, "c")
+      assert.equal(segments[0].children.length, 3)
+      return assert.equal(segments[0].children[0].id, "c")
+    })
+  })
+
+  return describe("addChildSegment", () =>
+    it("handles simple", function () {
+      let segments = [{ id: "a" }, { id: "b" }, { id: "c" }]
+      segments = PivotChartUtils.addChildSegment(segments, "b")
+      assert.equal(segments.length, 3)
+      return assert.equal(segments[1].children.length, 1)
+    }))
+})