Alert location parsing tests

.eslintrc.js

@@ -1,9 +1,7 @@
 module.exports = {
+  root: true,
   extends: ["airbnb-base", "prettier"],
-  ignorePatterns: [
-    "tests/translations/**/*.js",
-    "uswds*.js"
-  ],
+  ignorePatterns: ["tests/translations/**/*.js", "uswds*.js"],
   rules: {
     // For imports in the browser, file extensions are always required.
     "import/extensions": ["error", "always"],
@@ -46,6 +44,25 @@ module.exports = {
         "class-methods-use-this": 0,
       },
     },
+    {
+      files: ["api-interop-layer/**/*.test.js"],
+      extends: ["airbnb-base", "prettier"],
+      parserOptions: { ecmaVersion: 2024 },
+      rules: {
+        // This rule disallows using require() on files in devDependencies. But
+        // for test code, we'll rely on that heavily so we can disable the rule
+        // in here.
+        "import/no-extraneous-dependencies": [0],
+
+        // For imports in Node, file extensions are optional and discouraged as
+        // a matter of practice.
+        "import/extensions": ["error", "always"],
+
+        // chai provides "empty" expressions, such as `to.be.true`
+        "no-unused-expressions": "off"
+      },
+      env: { mocha: true },
+    },
     {
       files: [
         "tests/**/*.js",

.github/actions/javascript-lint/action.yml

@@ -15,10 +15,14 @@ runs:
       shell: bash
       run: cd tests/api && npm ci
 
+    - name: install api-interop-layer dependencies
+      shell: bash
+      run: cd api-interop-layer && npm ci
+
     - name: add problem matcher
       shell: bash
       run: echo "::add-matcher::${{ github.workspace }}/.github/workflows/problem-matcher-eslint.json"
 
     - name: run eslint
       shell: bash
-      run: npm run js-lint
+      run: npm run js-lint

.github/actions/setup-site/action.yml

@@ -51,3 +51,11 @@ runs:
     - name: clear the Drupal cache
       shell: bash
       run: make cc
+
+    # Restart the interop layer once the database is loaded. It immediately
+    # tries to run some queries, but if the database isn't ready, it'll crash
+    # and die.
+    - name: restart the interop layer
+      shell: bash
+      run: |
+        docker compose restart api-interop-layer

.github/workflows/code-standards.yaml

@@ -101,6 +101,28 @@ jobs:
         if: needs.should-test.outputs.yes == 'true'
         uses: ./.github/actions/style-lint
 
+  interop-layer-unit-tests:
+    name: interop layer unit tests
+    runs-on: ubuntu-latest
+    needs: [should-test]
+    defaults:
+      run:
+        working-directory: ./api-interop-layer/
+
+    steps:
+      - name: checkout
+        if: needs.should-test.outputs.yes == 'true'
+        uses: actions/checkout@v4
+      - name: setup node
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: npm
+      - name: install dependencies
+        run: npm ci
+      - name: test
+        run: npm test
+
   build-drupal-image:
     name: build Drupal image
     runs-on: ubuntu-latest

api-interop-layer/.c8rc.json

@@ -0,0 +1,6 @@
+{
+  "all": true,
+  "reporter": ["html"],
+  "exclude": ["node_modules/**", "coverage", "**/*.test.js"],
+  "require": ["mocha.js"]
+}

api-interop-layer/.gitignore

@@ -0,0 +1,2 @@
+.nyc_output
+coverage

api-interop-layer/Dockerfile

@@ -0,0 +1,11 @@
+FROM node:20
+
+RUN mkdir /app
+WORKDIR /app
+
+ADD ./package.json .
+ADD ./package-lock.json .
+
+RUN npm ci
+
+CMD npm start

api-interop-layer/data/alerts/geometry.js

@@ -0,0 +1,72 @@
+const unwindGeometryCollection = (geojson, parentIsCollection = false) => {
+  if (geojson.type === "GeometryCollection") {
+    const geometries = geojson.geometries.flatMap((geometry) =>
+      unwindGeometryCollection(geometry, true),
+    );
+    if (parentIsCollection) {
+      return geometries;
+    }
+
+    geojson.geometries = geometries;
+    return geojson;
+  }
+
+  return geojson;
+};
+
+export const generateAlertGeometry = async (db, rawAlert) => {
+  // if the alert already has geometry, nothing to do
+  if (rawAlert.geometry) {
+    return unwindGeometryCollection(rawAlert.geometry);
+  }
+
+  // if we have affected zones, generate a geometry from zones
+  const zones = rawAlert.properties.affectedZones;
+  if (Array.isArray(zones) && zones.length > 0) {
+    const sql = `
+      SELECT ST_ASGEOJSON(
+        ST_SIMPLIFY(
+          ST_SRID(
+            ST_COLLECT(shape),
+            0
+          ),
+          0.003
+        )
+      )
+        AS shape
+        FROM weathergov_geo_zones
+        WHERE id IN (${zones.map(() => "?").join(",")})`;
+    const [{ shape }] = await db.query(sql, zones);
+    if (shape) {
+      return unwindGeometryCollection(shape);
+    }
+  }
+
+  // if all geocodes are the same, generate a geometry from geocodes
+  const counties = rawAlert.properties.geocode?.SAME;
+  if (Array.isArray(counties) && counties.length > 0) {
+    const sql = `
+      SELECT ST_ASGEOJSON(
+        ST_SIMPLIFY(
+          ST_SRID(
+            ST_COLLECT(shape),
+            0
+          ),
+          0.003
+        )
+      )
+        AS shape
+        FROM weathergov_geo_counties
+        WHERE countyFips IN (${counties.map((c) => `'${c.slice(1)}'`).join(",")})`;
+    const [{ shape }] = await db.query(sql);
+
+    if (shape) {
+      return unwindGeometryCollection(shape);
+    }
+  }
+
+  // we cannot generate a geometry.
+  return null;
+}
+
+export default { generateAlertGeometry };

api-interop-layer/data/alerts/geometry.test.js

@@ -0,0 +1,100 @@
+import sinon from "sinon";
+import { expect } from "chai";
+import * as mariadb from "mariadb";
+import { generateAlertGeometry } from "./geometry.js";
+
+describe("alert geometries", () => {
+  const sandbox = sinon.createSandbox();
+  const db = {
+    query: sandbox.stub(),
+    end: () => Promise.resolve(),
+  };
+
+  // Do this before everything, so it'll happen before any describe blocks run,
+  // otherwise the connection creation won't be stubbed when the script is first
+  // imported below.
+  before(() => {
+    mariadb.default.createConnection.resolves(db);
+  });
+
+  beforeEach(() => {
+    sandbox.resetBehavior();
+    sandbox.resetHistory();
+  });
+
+  it("returns an alert with a geometry as-is", async () => {
+    const rawAlert = {
+      geometry: "existing geometry",
+    };
+
+    const geometry = await generateAlertGeometry(db, rawAlert);
+    expect(geometry).to.equal("existing geometry");
+  });
+
+  it("autogenerates a geometry from affected zones", async () => {
+    const affectedZones = ["zone 1", "zone 2", "zone 3"];
+    const rawAlert = {
+      geometry: false,
+      properties: {
+        affectedZones,
+      },
+    };
+    const query = `SELECT ST_ASGEOJSON(
+        ST_SIMPLIFY(
+          ST_SRID(
+            ST_COLLECT(shape),
+            0
+          ),
+          0.003
+        )
+      )
+        AS shape
+        FROM weathergov_geo_zones
+        WHERE id IN (?,?,?)`;
+    db.query.withArgs(sinon.match(query), sinon.match.same(affectedZones))
+      .resolves([{ shape: { combined: "zones" } }]);
+
+    const geometry = await generateAlertGeometry(db, rawAlert);
+    expect(geometry).to.eql({ combined: "zones" });
+  });
+
+  it("autogenerates a geometry from same geocodes if no zones are present", async () => {
+    const rawAlert = {
+     geometry: false,
+      properties: {
+        geocode: {
+          // SAME code is FIPS code with a leading zero. The leading
+          // zero gets stripped out, so we need to include it here
+          // so we get what we expect later.
+          "SAME": ["0county 1", "0county 2", "0county 3"],
+        },
+      },
+    };
+    const query = `SELECT ST_ASGEOJSON(
+        ST_SIMPLIFY(
+          ST_SRID(
+            ST_COLLECT(shape),
+            0
+          ),
+          0.003
+        )
+      )
+        AS shape
+        FROM weathergov_geo_counties
+        WHERE countyFips IN ('county 1','county 2','county 3')`;
+    db.query.withArgs(sinon.match(query)).resolves([{ shape: { combined: "county" } }]);
+
+    const geometry = await generateAlertGeometry(db, rawAlert);
+    expect(geometry).to.eql({ combined: "county" });
+  });
+
+  it("returns null geometry if no zones or different geocodes are present", async () => {
+    const rawAlert = {
+      geometry: false,
+      properties: {},
+    };
+
+    const geometry = await generateAlertGeometry(db, rawAlert);
+    expect(geometry).to.be.null;
+  });
+});