move more logic out of instrumentdata, add tests for logic moved

Author: rerpha

app/components/Instrument.test.ts

@@ -1,5 +1,24 @@
-import { findPVInDashboard } from "@/app/components/Instrument";
-import { DashboardArr, IfcPV } from "@/app/types";
+import {
+  CSSB,
+  findPVInDashboard,
+  findPVInGroups,
+  getGroupsWithBlocksFromConfigOutput,
+  RC_ENABLE,
+  RC_INRANGE,
+  SP_RBV, storePrecision,
+  subscribeToBlockPVs,
+  toPrecision,
+  yesToBoolean,
+} from "@/app/components/Instrument";
+import {
+  ConfigOutput,
+  DashboardArr,
+  IfcBlock,
+  IfcGroup,
+  IfcPV, IfcPVWSMessage,
+  IfcPVWSRequest,
+  PVWSRequestType,
+} from "@/app/types";
 
 test("findPVinDashboard finds a pv in the dashboard and returns it", () => {
   const prefix = "UNITTESTING";
@@ -69,3 +88,145 @@ test("findPVinDashboard does not find a PV in the dashboard and returns undefine
   const result = findPVInDashboard(dashboard, pvToTestFor.pvaddress);
   expect(result).toBe(undefined);
 });
+
+test("findPVInGroups returns a block when it finds one", () => {
+  const blockName = "blockName";
+  const prefix = "IN:INSTRUMENT";
+  const groups: Array<IfcGroup> = [
+    {
+      name: "aGroup",
+      blocks: [
+        {
+          human_readable_name: blockName,
+          pvaddress: "some:underlying:pv:name",
+        },
+      ],
+    },
+  ];
+
+  findPVInGroups(groups, prefix, prefix + CSSB + blockName);
+});
+
+test("subscribeToBlockPVs subscribes to all run control PVs", () => {
+  const mockSendJsonMessage = jest.fn();
+  const aBlock = "INST:CS:SB:SomeBlock";
+  subscribeToBlockPVs(mockSendJsonMessage, aBlock);
+  expect(mockSendJsonMessage.mock.calls.length).toBe(1);
+  const expectedCall: IfcPVWSRequest = {
+    type: PVWSRequestType.subscribe,
+    pvs: [aBlock, aBlock + RC_ENABLE, aBlock + RC_INRANGE, aBlock + SP_RBV],
+  };
+  expect(JSON.stringify(mockSendJsonMessage.mock.calls[0][0])).toBe(
+    JSON.stringify(expectedCall),
+  );
+});
+
+test("toPrecision does nothing to string value ", () => {
+  const expectedValue = "untouched";
+  const aBlock: IfcBlock = {
+    pvaddress: "SOME:BLOCK:STR",
+    value: expectedValue,
+  };
+  expect(toPrecision(aBlock, expectedValue)).toBe(expectedValue);
+});
+
+test("toPrecision does nothing to block without pv ", () => {
+  const expectedValue = 0.00123456;
+  const aBlock: IfcBlock = {
+    pvaddress: "SOME:BLOCK:STR",
+    value: expectedValue,
+  };
+  expect(toPrecision(aBlock, expectedValue)).toBe(expectedValue);
+});
+
+test("toPrecision truncates block if it has precision", () => {
+  const originalValue = 0.00123456;
+  const precision = 3;
+  const aBlock: IfcBlock = {
+    pvaddress: "SOME:BLOCK:STR",
+    value: originalValue,
+    precision: precision,
+  };
+  expect(toPrecision(aBlock, originalValue)).toBe(
+    originalValue.toFixed(precision),
+  );
+});
+
+test("yesToBoolean works with YES as value", () => {
+  expect(yesToBoolean("YES")).toBe(true);
+});
+
+test("yesToBoolean works with NO as value", () => {
+  expect(yesToBoolean("NO")).toBe(false);
+});
+
+test("getGroupsWithBlocksFromConfigOutput gets blocks from blockserver groups", () => {
+  const blockNameToTest = "aBlock";
+  const groupNameToTest = "aGroup";
+  const prefix = "TESTING";
+  const mockSendJsonMessage = jest.fn();
+
+  const configOutput: ConfigOutput = {
+    groups: [{ blocks: [blockNameToTest], name: groupNameToTest }],
+    blocks: [
+      {
+        name: blockNameToTest,
+        component: "",
+        local: true,
+        pv: "A:BLOCK",
+        set_block: false,
+        highlimit: 0,
+        lowlimit: 0,
+        log_rate: 0,
+        log_deadband: 0,
+        log_periodic: true,
+        runcontrol: true,
+        suspend_on_invalid: true,
+        visible: true,
+      },
+    ],
+    components: [],
+    description: "",
+    name: "",
+    configuresBlockGWAndArchiver: false,
+    iocs: [],
+    isDynamic: false,
+    isProtected: false,
+    synoptic: "",
+    component_iocs: [],
+    history: [],
+  };
+  const groups = getGroupsWithBlocksFromConfigOutput(
+    configOutput,
+    mockSendJsonMessage,
+    prefix,
+  );
+  expect(groups[0].name).toBe(groupNameToTest);
+  expect(groups[0].blocks[0].human_readable_name).toBe(blockNameToTest);
+});
+
+test("subscribeToBlockPVs subscribes to blocks, their run control and their SP:RBV PVs", () => {
+  const mockSendJsonMessage = jest.fn();
+  const blockAddress = "IN:INST:CS:SB:Block1";
+  subscribeToBlockPVs(mockSendJsonMessage, blockAddress);
+  expect(mockSendJsonMessage).toBeCalledTimes(1);
+  const call: Array<string> = mockSendJsonMessage.mock.calls[0][0].pvs;
+  expect(call).toEqual(
+    expect.arrayContaining([
+      blockAddress,
+      blockAddress + RC_ENABLE,
+      blockAddress + RC_INRANGE,
+      blockAddress + SP_RBV,
+    ]),
+  );
+});
+
+test("storePrecision adds precision to a block if it is the first update", () => {
+  const precision = 3;
+  const message: IfcPVWSMessage = {type:"update", pv:"",precision:precision}
+  let blockWithoutPrecision: IfcBlock = {pvaddress:""}
+  storePrecision(message, blockWithoutPrecision)
+  expect(blockWithoutPrecision.precision).toEqual(precision)
+})
+
+

app/components/Instrument.ts

@@ -1,5 +1,18 @@
-import { DashboardArr, IfcBlock, IfcGroup, IfcPV } from "@/app/types";
-import { CSSB } from "@/app/components/InstrumentData";
+import {
+  ConfigOutput,
+  ConfigOutputBlock,
+  DashboardArr,
+  IfcBlock,
+  IfcGroup,
+  IfcPV,
+  IfcPVWSMessage,
+  IfcPVWSRequest,
+  PVWSRequestType,
+} from "@/app/types";
+import {
+  ExponentialOnThresholdFormat,
+  findPVByAddress,
+} from "@/app/components/PVutils";
 
 const DASHBOARD = "CS:DASHBOARD:TAB:";
 
@@ -186,7 +199,89 @@ export function findPVInDashboard(
   dashboard: DashboardArr,
   pvAddress: string,
 ): undefined | IfcPV {
-  return dashboard.flat(3).find((pv: IfcPV) => pv.pvaddress == pvAddress);
+  return findPVByAddress(dashboard.flat(3), pvAddress);
+}
+
+export const RC_ENABLE = ":RC:ENABLE";
+export const RC_INRANGE = ":RC:INRANGE";
+export const SP_RBV = ":SP:RBV";
+export const CSSB = "CS:SB:";
+
+export function toPrecision(
+  block: IfcPV,
+  pvVal: number | string,
+): string | number {
+  return block.precision
+    ? ExponentialOnThresholdFormat(pvVal, block.precision)
+    : pvVal;
+}
+
+export function storePrecision(updatedPV: IfcPVWSMessage, block: IfcBlock) {
+  const prec = updatedPV.precision;
+  if (prec != null && prec > 0 && !block.precision) {
+    // this is likely the first update, and contains precision information which is not repeated on a normal value update - store this in the block for later truncation (see below)
+    block.precision = prec;
+  }
+}
+
+export function yesToBoolean(pvVal: string | number) {
+  return pvVal == "YES";
+}
+
+export function subscribeToBlockPVs(
+  sendJsonMessage: (a: IfcPVWSRequest) => void,
+  block_address: string,
+) {
+  /**
+   * Subscribes to a block and its associated run control PVs
+   */
+  sendJsonMessage({
+    type: PVWSRequestType.subscribe,
+    pvs: [
+      block_address,
+      block_address + RC_ENABLE,
+      block_address + RC_INRANGE,
+      block_address + SP_RBV,
+    ],
+  });
+}
+
+/**
+ * Parse the blockserver's current configuration output
+ * and create an array of groups which contain blocks.
+ */
+export function getGroupsWithBlocksFromConfigOutput(
+  configOutput: ConfigOutput,
+  sendJsonMessage: (a: IfcPVWSRequest) => void,
+  prefix: string,
+): Array<IfcGroup> {
+  const groups = configOutput.groups;
+  let newGroups: Array<IfcGroup> = [];
+  for (const group of groups) {
+    const groupName = group.name;
+    let blocks: Array<IfcBlock> = [];
+    for (const block of group.blocks) {
+      const newBlock = configOutput.blocks.find(
+        (b: ConfigOutputBlock) => b.name === block,
+      );
+      if (newBlock) {
+        blocks.push({
+          pvaddress: newBlock.pv,
+          human_readable_name: newBlock.name,
+          low_rc: newBlock.lowlimit,
+          high_rc: newBlock.highlimit,
+          visible: newBlock.visible,
+        });
+        const fullyQualifiedBlockPVAddress = prefix + CSSB + newBlock.name;
+        subscribeToBlockPVs(sendJsonMessage, fullyQualifiedBlockPVAddress);
+      }
+    }
+    newGroups.push({
+      name: groupName,
+      blocks: blocks,
+    });
+  }
+  return newGroups;
 }
 
 export function findPVInGroups(