@mwater/visualization 5.0.0

package/test/LayeredChartTests.ts

@@ -0,0 +1,88 @@
+// TODO: This file was created by bulk-decaffeinate.
+// Sanity-check the conversion and remove this comment.
+import _ from "lodash"
+import { assert } from "chai"
+import * as fixtures from "./fixtures"
+import LayeredChart from "../src/widgets/charts/layered/LayeredChart"
+import canonical from "canonical-json"
+
+function compare(actual: any, expected: any) {
+  return assert.equal(canonical(actual), canonical(expected), "\n" + canonical(actual) + "\n" + canonical(expected))
+}
+
+describe("LayeredChart", function () {
+  before(function () {
+    this.schema = fixtures.simpleSchema()
+    this.chart = new LayeredChart()
+
+    this.exprNumber = { type: "field", table: "t1", column: "number" }
+    this.exprText = { type: "field", table: "t1", column: "text" }
+    this.exprDate = { type: "field", table: "t1", column: "date" }
+    this.exprEnum = { type: "field", table: "t1", column: "enum" }
+
+    this.axisNumber = { expr: this.exprNumber }
+    this.axisNumberSum = { expr: this.exprNumber, aggr: "sum" }
+    this.axisEnum = { expr: this.exprEnum }
+    this.axisEnumset = { expr: this.exprEnumset }
+    this.axisText = { expr: this.exprText }
+    return (this.axisDate = { expr: this.exprDate })
+  })
+
+  return describe("cleanDesign", () =>
+    // Removed as was making impossible to choose other than count
+    // it "defaults y axis to count", ->
+    //   design = {
+    //     type: "bar"
+    //     layers: [
+    //       { axes: { x: @axisEnum, y: null }, table: "t1" }
+    //     ]
+    //   }
+    //
+    //   design = @chart.cleanDesign(design, @schema)
+    //
+    //   expectedY = {
+    //     expr: { type: "id", table: "t1" }
+    //     xform: null
+    //     aggr: "count"
+    //   }
+    //
+    //   compare(design.layers[0].axes.y, expectedY)
+
+    // it "does not default y axis if scatter", ->
+    //   design = {
+    //     type: "scatter"
+    //     layers: [
+    //       { axes: { x: @axisEnum, y: null }, table: "t1" }
+    //     ]
+    //   }
+
+    // it "does not default y axis if scatter", ->
+    //   design = {
+    //     type: "scatter"
+    //     layers: [
+    //       { axes: { x: @axisEnum, y: null }, table: "t1" }
+    //     ]
+    //   }
+
+    //   design = @chart.cleanDesign(design, @schema)
+
+    //   assert not design.layers[0].axes.y
+
+    it("removes aggr from y if scatter", function () {
+      let design = {
+        type: "scatter",
+        layers: [
+          {
+            axes: { x: this.axisEnum, y: { expr: { type: "id", table: "t1" }, xform: null, aggr: "count" } },
+            table: "t1"
+          }
+        ]
+      }
+
+      design = this.chart.cleanDesign(design, this.schema)
+
+      const expectedY = this.axisNumber
+
+      return assert(!design.layers[0].axes.y)
+    }))
+})

package/test/LegoLayoutEngineTests.ts

@@ -0,0 +1,69 @@
+// TODO: This file was created by bulk-decaffeinate.
+// Sanity-check the conversion and remove this comment.
+import { assert } from "chai"
+import _ from "lodash"
+import LegoLayoutEngine from "../src/layouts/grid/LegoLayoutEngine"
+
+describe("LegoLayoutEngine", function () {
+  before(function () {
+    // 6 blocks across, each 10 px
+    return (this.le = new LegoLayoutEngine(60, 6))
+  })
+
+  it("snaps to grid", function () {
+    const rectLayout = this.le.rectToLayout({ x: 11, y: 19, width: 32, height: 42 })
+    return assert.deepEqual(rectLayout, { x: 1, y: 2, w: 3, h: 4 })
+  })
+
+  it("shifts existing to right if room", function () {
+    const existing = { x: 1, y: 2, w: 1, h: 1 }
+    const newOne = { x: 1, y: 2, w: 3, h: 4 }
+
+    let layouts = {
+      existing,
+      newOne
+    }
+
+    layouts = this.le.performLayout(layouts, "newOne")
+    return assert.deepEqual(layouts, {
+      existing: { x: 4, y: 2, w: 1, h: 1 },
+      newOne: { x: 1, y: 2, w: 3, h: 4 }
+    })
+  })
+
+  it("shifts existing to down if no room", function () {
+    const existing = { x: 1, y: 2, w: 5, h: 1 }
+    const newOne = { x: 1, y: 2, w: 3, h: 4 }
+
+    let layouts = {
+      existing,
+      newOne
+    }
+
+    layouts = this.le.performLayout(layouts, "newOne")
+    return assert.deepEqual(layouts, {
+      existing: { x: 0, y: 6, w: 5, h: 1 }, // Moves to left
+      newOne: { x: 1, y: 2, w: 3, h: 4 }
+    })
+  })
+
+  it("calculates height", function () {
+    const existing = { x: 1, y: 2, w: 5, h: 1 }
+
+    const layouts = {
+      existing
+    }
+
+    const height = this.le.calculateHeight(layouts)
+    return assert.equal(height, 40)
+  })
+
+  return it("appends layout", function () {
+    const existing = { x: 1, y: 2, w: 5, h: 1 }
+
+    const layouts = [existing]
+
+    const newOne = this.le.appendLayout(layouts, 4, 3)
+    return assert.deepEqual(newOne, { x: 0, y: 3, w: 4, h: 3 })
+  })
+})

package/test/MWaterGlobalFiltersComponentTests.ts

@@ -0,0 +1,130 @@
+// TODO: This file was created by bulk-decaffeinate.
+// Sanity-check the conversion and remove this comment.
+import { createElement as R } from "react"
+import sinon from "sinon"
+import enzyme from "enzyme"
+import { assert } from "chai"
+import { Schema } from "@mwater/expressions"
+import * as ui from "@mwater/react-library/lib/bootstrap"
+import { IdLiteralComponent } from "@mwater/expressions-ui"
+import MWaterGlobalFiltersComponent from "../src/MWaterGlobalFiltersComponent"
+
+enzyme.configure({ adapter: new (require("enzyme-adapter-react-16"))() }) // Configure enzyme for react 16
+
+describe("MWaterGlobalFiltersComponent", function () {
+  it("extracts _managed_by filter", function () {
+    const wrapper = enzyme.shallow(
+      R(MWaterGlobalFiltersComponent, {
+        schema: {},
+        dataSource: {},
+        filterableTables: [],
+        globalFilters: [
+          {
+            columnId: "_managed_by",
+            columnType: "id",
+            op: "within",
+            exprs: [{ type: "literal", valueType: "id", idTable: "subjects", value: "group:xyz" }]
+          }
+        ],
+        onChange() {}
+      })
+    )
+
+    const managedByControl = wrapper.find(IdLiteralComponent).at(0)
+    return assert.equal(managedByControl.prop("value"), "xyz", "Should be displaying group")
+  })
+
+  it("updates _managed_by", function () {
+    const onChange = sinon.spy()
+
+    const wrapper = enzyme.shallow(
+      R(MWaterGlobalFiltersComponent, {
+        schema: {},
+        dataSource: {},
+        filterableTables: [],
+        globalFilters: [
+          {
+            columnId: "_managed_by",
+            columnType: "id",
+            op: "within",
+            exprs: [{ type: "literal", valueType: "id", idTable: "subjects", value: "group:xyz" }]
+          }
+        ],
+        onChange
+      })
+    )
+
+    const managedByControl = wrapper.find(IdLiteralComponent).at(0)
+    managedByControl.prop("onChange")("abc")
+
+    // Should set filter
+    return assert(
+      onChange.calledWith([
+        {
+          columnId: "_managed_by",
+          columnType: "id",
+          op: "within",
+          exprs: [{ type: "literal", valueType: "id", idTable: "subjects", value: "group:abc" }]
+        }
+      ])
+    )
+  })
+
+  it("extracts admin_region", function () {
+    const wrapper = enzyme.shallow(
+      R(MWaterGlobalFiltersComponent, {
+        schema: {},
+        dataSource: {},
+        filterableTables: [],
+        globalFilters: [
+          {
+            columnId: "admin_region",
+            columnType: "id",
+            op: "within any",
+            exprs: [{ type: "literal", valueType: "id[]", idTable: "admin_regions", value: [123, 456] }]
+          }
+        ],
+        onChange() {}
+      })
+    )
+
+    const adminRegionsControl = wrapper.find(IdLiteralComponent).at(1)
+    return assert.deepEqual(adminRegionsControl.prop("value"), [123, 456], "Should be displaying admin_region")
+  })
+
+  return it("updates admin_region", function () {
+    const onChange = sinon.spy()
+
+    const wrapper = enzyme.shallow(
+      R(MWaterGlobalFiltersComponent, {
+        schema: {},
+        dataSource: {},
+        filterableTables: [],
+        globalFilters: [
+          {
+            columnId: "admin_region",
+            columnType: "id",
+            op: "within any",
+            exprs: [{ type: "literal", valueType: "id[]", idTable: "admin_regions", value: [123, 456] }]
+          }
+        ],
+        onChange
+      })
+    )
+
+    const adminRegionsControl = wrapper.find(IdLiteralComponent).at(1)
+    adminRegionsControl.prop("onChange")([789])
+
+    // Should set filter
+    return assert(
+      onChange.calledWith([
+        {
+          columnId: "admin_region",
+          columnType: "id",
+          op: "within any",
+          exprs: [{ type: "literal", valueType: "id[]", idTable: "admin_regions", value: [789] }]
+        }
+      ])
+    )
+  })
+})

package/test/MWaterResponsesFilterComponentTests.ts

@@ -0,0 +1,164 @@
+// TODO: This file was created by bulk-decaffeinate.
+// Sanity-check the conversion and remove this comment.
+import { createElement as R } from "react"
+import sinon from "sinon"
+import enzyme from "enzyme"
+import { assert } from "chai"
+import { Schema } from "@mwater/expressions"
+import * as ui from "@mwater/react-library/lib/bootstrap"
+import MWaterResponsesFilterComponent from "../src/MWaterResponsesFilterComponent"
+
+enzyme.configure({ adapter: new (require("enzyme-adapter-react-16"))() }) // Configure enzyme for react 16
+
+describe("MWaterResponsesFilterComponent", function () {
+  before(function () {
+    this.schema = new Schema()
+    this.schema = this.schema.addTable({
+      id: "responses:xyz",
+      name: { en: "Survey" },
+      primaryKey: "_id",
+      contents: [
+        { id: "status", type: "enum", name: { en: "Status" }, enumValues: [{ id: "final", name: { en: "Final" } }] },
+        {
+          id: "data:site1",
+          type: "join",
+          name: { en: "Site1" },
+          join: {
+            type: "n-1",
+            toTable: "entities.water_point",
+            fromColumn: "data:site1",
+            toColumn: "code"
+          }
+        },
+        {
+          id: "data:site2",
+          type: "join",
+          name: { en: "Site2" },
+          join: {
+            type: "n-1",
+            toTable: "entities.community",
+            fromColumn: "data:site2",
+            toColumn: "code"
+          }
+        }
+      ]
+    })
+
+    this.finalFilter = {
+      type: "op",
+      op: "= any",
+      table: "responses:xyz",
+      exprs: [
+        { type: "field", table: "responses:xyz", column: "status" },
+        { type: "literal", valueType: "enumset", value: ["final"] }
+      ]
+    }
+
+    this.latestFilter = {
+      type: "op",
+      op: "is latest",
+      table: "responses:xyz",
+      exprs: [{ type: "field", table: "responses:xyz", column: "data:site1" }]
+    }
+
+    this.latestFinalFilter = {
+      type: "op",
+      op: "is latest",
+      table: "responses:xyz",
+      exprs: [{ type: "field", table: "responses:xyz", column: "data:site1" }, this.finalFilter]
+    }
+
+    return (this.otherFilter = { type: "field", table: "responses:xyz", column: "other" })
+  })
+
+  it("filters from none to final", function () {
+    const onChange = sinon.spy()
+    const wrapper = enzyme.shallow(
+      R(MWaterResponsesFilterComponent, {
+        table: "responses:xyz",
+        schema: this.schema,
+        filter: null,
+        onFilterChange: onChange
+      })
+    )
+
+    // Set checkbox to true
+    wrapper.find(ui.Checkbox).prop("onChange")(true)
+
+    // Should set filter
+    return assert(onChange.calledWith(this.finalFilter))
+  })
+
+  it("clears final filter, preserving others", function () {
+    const onChange = sinon.spy()
+    const filter = {
+      type: "op",
+      table: "responses:xyz",
+      op: "and",
+      exprs: [this.otherFilter, this.finalFilter]
+    }
+    const wrapper = enzyme.shallow(
+      R(MWaterResponsesFilterComponent, {
+        table: "responses:xyz",
+        schema: this.schema,
+        filter,
+        onFilterChange: onChange
+      })
+    )
+
+    // Final checkbox should be true
+    assert.isTrue(wrapper.find(ui.Checkbox).prop("value"))
+
+    // Set checkbox to false
+    wrapper.find(ui.Checkbox).prop("onChange")(false)
+
+    // Should set filter
+    return assert.isTrue(onChange.calledWith(this.otherFilter))
+  })
+
+  it("lists site questions + all", function () {
+    const wrapper = enzyme.shallow(
+      R(MWaterResponsesFilterComponent, {
+        table: "responses:xyz",
+        schema: this.schema,
+        filter: null,
+        onFilterChange() {}
+      })
+    )
+    return assert.equal(wrapper.find(ui.Radio).length, 3)
+  })
+
+  it("adds non-final site", function () {
+    const onChange = sinon.spy()
+    const wrapper = enzyme.shallow(
+      R(MWaterResponsesFilterComponent, {
+        table: "responses:xyz",
+        schema: this.schema,
+        filter: null,
+        onFilterChange: onChange
+      })
+    )
+
+    const radio = wrapper.find(ui.Radio).at(1)
+    radio.prop("onChange")(radio.prop("radioValue"))
+
+    return assert.isTrue(onChange.calledWith(this.latestFilter), JSON.stringify(onChange.firstCall.args))
+  })
+
+  return it("adds final site", function () {
+    const onChange = sinon.spy()
+    const wrapper = enzyme.shallow(
+      R(MWaterResponsesFilterComponent, {
+        table: "responses:xyz",
+        schema: this.schema,
+        filter: this.finalFilter,
+        onFilterChange: onChange
+      })
+    )
+
+    const radio = wrapper.find(ui.Radio).at(1)
+    radio.prop("onChange")(radio.prop("radioValue"))
+
+    return assert.isTrue(onChange.calledWith(this.latestFinalFilter), JSON.stringify(onChange.firstCall.args))
+  })
+})

package/test/QuickfilterCompilerTests.ts

@@ -0,0 +1,167 @@
+// 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 QuickfilterCompiler from "../src/quickfilter/QuickfilterCompiler"
+import canonical from "canonical-json"
+
+function compare(actual: any, expected: any) {
+  return assert.equal(canonical(actual), canonical(expected), "\nACT: " + canonical(actual) + "\n\nEXP: " + canonical(expected))
+}
+
+describe("QuickfilterCompiler", function () {
+  before(function () {
+    this.schema = fixtures.simpleSchema()
+    return (this.qc = new QuickfilterCompiler(this.schema))
+  })
+
+  it("compiles enum filter", function () {
+    const filters = this.qc.compile([{ expr: { type: "field", table: "t1", column: "enum" }, label: "Enum" }], ["a"])
+    return compare(filters, [
+      {
+        table: "t1",
+        jsonql: {
+          type: "op",
+          op: "=",
+          exprs: [
+            { type: "field", tableAlias: "{alias}", column: "enum" },
+            { type: "literal", value: "a" }
+          ]
+        }
+      }
+    ])
+  })
+
+  it("compiles enumset filter", function () {
+    const filters = this.qc.compile(
+      [{ expr: { type: "field", table: "t1", column: "enumset" }, label: "Enumset" }],
+      ["a"]
+    )
+    return compare(filters, [
+      {
+        table: "t1",
+        jsonql: {
+          type: "op",
+          op: "@>",
+          exprs: [
+            { type: "op", op: "to_jsonb", exprs: [{ type: "field", tableAlias: "{alias}", column: "enumset" }] },
+            { type: "op", op: "::jsonb", exprs: [{ type: "literal", value: '["a"]' }] }
+          ]
+        }
+      }
+    ])
+  })
+
+  it("compiles multi filter", function () {
+    const filters = this.qc.compile(
+      [{ expr: { type: "field", table: "t1", column: "enum" }, label: "Enum", multi: true }],
+      [["a"]]
+    )
+    return compare(filters, [
+      {
+        table: "t1",
+        jsonql: {
+          type: "op",
+          op: "=",
+          exprs: [
+            { type: "field", tableAlias: "{alias}", column: "enum" },
+            { type: "literal", value: "a" }
+          ]
+        }
+      }
+    ])
+  })
+
+  it("compiles enumset multi filter", function () {
+    const filters = this.qc.compile(
+      [{ expr: { type: "field", table: "t1", column: "enumset" }, label: "Enumset", multi: true }],
+      [["a"]]
+    )
+    compare(filters, [
+      {
+        "jsonql": {
+          "exprs": [
+            {
+              "exprs": [
+                {
+                  "column": "enumset",
+                  "tableAlias": "{alias}",
+                  "type": "field"
+                }
+              ],
+              "op": "to_jsonb",
+              "type": "op"
+            },
+            {
+              "exprs": [
+                {
+                  "expr": {
+                    "exprs": [
+                      {
+                        "tableAlias": "elements",
+                        "type": "field"
+                      }
+                    ],
+                    "op": "array_agg",
+                    "type": "op"
+                  },
+                  "from": {
+                    "alias": "elements",
+                    "expr": {
+                      "exprs": [
+                        {
+                          "exprs": [
+                            {
+                              "type": "literal",
+                              "value": "[\"a\"]"
+                            }
+                          ],
+                          "op": "::jsonb",
+                          "type": "op"
+                        }
+                      ],
+                      "op": "jsonb_array_elements",
+                      "type": "op"
+                    },
+                    "type": "subexpr"
+                  },
+                  "type": "scalar"
+                }
+              ],
+              "op": "::jsonb[]",
+              "type": "op"
+            }
+          ],
+          "modifier": "any",
+          "op": "@>",
+          "type": "op"
+        },
+        "table": "t1"
+      }
+    ])
+  })
+
+  it("compiles filter with locks", function () {
+    const filters = this.qc.compile(
+      [{ expr: { type: "field", table: "t1", column: "enum" }, label: "Enum" }],
+      ["a"],
+      [{ expr: { type: "field", table: "t1", column: "enum" }, value: "b" }]
+    )
+    return compare(filters, [
+      {
+        table: "t1",
+        jsonql: {
+          type: "op",
+          op: "=",
+          exprs: [
+            { type: "field", tableAlias: "{alias}", column: "enum" },
+            { type: "literal", value: "b" }
+          ]
+        }
+      }
+    ])
+  })
+
+  return it("ignores null values")
+})

package/test/TestComponent.ts

@@ -0,0 +1,49 @@
+// TODO: This file was created by bulk-decaffeinate.
+// Sanity-check the conversion and remove this comment.
+let TestComponent
+import React from "react"
+import ReactDOM from "react-dom"
+import TestUtils from "react-addons-test-utils"
+const R = React.createElement
+
+export default TestComponent = class TestComponent {
+  constructor(elem: any) {
+    this.comp = TestUtils.renderIntoDocument(React.createElement(ComponentWrapper, { elem }))
+  }
+
+  setElement(elem: any) {
+    return this.comp.setElement(elem)
+  }
+
+  getComponent() {
+    return this.comp.getComponent()
+  }
+
+  getComponentNode() {
+    return this.comp.getComponentNode()
+  }
+}
+
+// Wraps a react component, re-render
+class ComponentWrapper extends React.Component {
+  constructor(props: any) {
+    super(props)
+    this.state = { elem: this.props.elem }
+  }
+
+  setElement = (elem: any) => {
+    return this.setState({ elem })
+  }
+
+  getComponent() {
+    return this.refs.comp
+  }
+
+  getComponentNode() {
+    return ReactDOM.findDOMNode(this.refs.comp)
+  }
+
+  render() {
+    return R("div", null, React.cloneElement(this.state.elem, { ref: "comp" }))
+  }
+}