motion-master-client 0.0.21 → 0.0.22

package/src/lib/motion-master-req-res-client.spec.ts

@@ -0,0 +1,740 @@
+import { of } from "rxjs";
+import { TestScheduler } from "rxjs/testing";
+import { Device } from "./device";
+import { MotionMasterReqResClient } from "./motion-master-req-res-client";
+import { MotionMasterReqResSocket } from "./motion-master-req-res-socket";
+
+// jest.setTimeout(10000);
+
+describe('MotionMasterReqResClient', () => {
+
+  let request: MotionMasterReqResClient;
+  let scheduler: TestScheduler;
+
+  beforeEach(() => {
+    const socket = jest.fn() as unknown as MotionMasterReqResSocket;
+    socket.send = jest.fn();
+    request = new MotionMasterReqResClient(socket);
+
+    scheduler = new TestScheduler((actual, expected) => {
+      return expect(actual).toEqual(expected);
+    });
+  });
+
+  afterEach(() => {
+    scheduler.flush();
+    jest.restoreAllMocks();
+  });
+
+  describe('pingSystem', () => {
+    it('should send PingSystem request message and return EMPTY observable', () => {
+      scheduler.run(({ expectObservable }) => {
+        const result = request.pingSystem('pingSystemMessageId');
+
+        expect(request.socket.send).toBeCalledTimes(1);
+        expect(request.socket.send).toBeCalledWith({
+          id: 'pingSystemMessageId',
+          request: {
+            pingSystem: {},
+          },
+        });
+        expectObservable(result).toBe('|');
+      });
+    });
+  });
+
+  describe('getSystemVersion', () => {
+    it('should send GetSystemVersion request message and return an observable of SystemVersion status', () => {
+      scheduler.run(({ hot, expectObservable }) => {
+        const message$ = hot('a', {
+          a: {
+            "id": "getSystemVersionMessageId",
+            "status": {
+              "systemVersion": {
+                "version": "4.8.4"
+              },
+              "type": "systemVersion"
+            },
+            "type": "status"
+          }
+        });
+        Object.defineProperty(request.socket, 'message$', { value: message$ });
+
+        const result = request.getSystemVersion(1000, 'getSystemVersionMessageId');
+
+        expect(request.socket.send).toBeCalledTimes(1);
+        expect(request.socket.send).toBeCalledWith({
+          id: 'getSystemVersionMessageId',
+          request: {
+            getSystemVersion: {},
+          },
+        });
+        expectObservable(result).toBe('(a|)', {
+          a: {
+            version: '4.8.4',
+            request: 'succeeded',
+            messageId: 'getSystemVersionMessageId'
+          }
+        });
+      });
+    });
+  });
+
+  describe('resolveDeviceAddress', () => {
+    const device: Device = {
+      "id": "9500-02-0008895-1950",
+      "deviceAddress": 3139914318,
+      "hardwareDescription": {
+        "fileVersion": "1.0.0",
+        "device": {
+          "macAddress": "40:49:8A:01:0d:75",
+          "serialNumber": "9500-02-0008895-1950",
+          "name": "SOMANET Servo Node 1000-D EtherCAT",
+          "id": "9500",
+          "version": "02",
+          "keyId": "2310",
+          "components": []
+        }
+      }
+    };
+    it('should throw an error if deviceRefObj is not valid', () => {
+      return scheduler.run(({ expectObservable }) => {
+        const result$ = request.resolveDeviceAddress({});
+
+        expectObservable(result$).toBe('#', null, new Error('Device ref object is not valid {}'));
+      });
+    });
+
+    it('should just return device address if deviceRefObj contains one', () => {
+      return scheduler.run(({ expectObservable }) => {
+        const result$ = request.resolveDeviceAddress({ deviceAddress: 3139914318 });
+
+        const getCachedDeviceByDeviceRefObj = jest.spyOn(request, 'getCachedDeviceByDeviceRefObj');
+        const getDevices = jest.spyOn(request, 'getDevices');
+
+        expectObservable(result$).toBe('(a|)', { a: 3139914318 });
+        expect(getCachedDeviceByDeviceRefObj).not.toBeCalled();
+        expect(getDevices).not.toBeCalled();
+      });
+    });
+
+    xit('should return device address by position from the cached devices without making request to get devices', () => {
+      return scheduler.run(async ({ expectObservable }) => {
+        request.deviceMap.set('9500-02-0008895-1950', { deviceAddress: 3139914318, id: '9500-02-0008895-1950' });
+
+        const getCachedDeviceByDeviceRefObj = jest.spyOn(request, 'getCachedDeviceByDeviceRefObj');
+        const getDevices = jest.spyOn(request, 'getDevices');
+
+        const result$ = request.resolveDeviceAddress({ devicePosition: 0 });
+
+        expectObservable(result$).toBe('(a|)', { a: 3139914318 });
+        expect(getCachedDeviceByDeviceRefObj).toBeCalledTimes(1);
+        expect(getDevices).not.toBeCalled();
+      });
+    });
+
+    it('should return device address by serial number from the cached devices without making request to get devices', () => {
+      return scheduler.run(async ({ expectObservable }) => {
+        request.deviceMap.set('9500-02-0008895-1950', { deviceAddress: 3139914318, id: '9500-02-0008895-1950' });
+
+        const getCachedDeviceByDeviceRefObj = jest.spyOn(request, 'getCachedDeviceByDeviceRefObj');
+        const getDevices = jest.spyOn(request, 'getDevices');
+
+        const result$ = request.resolveDeviceAddress({ deviceSerialNumber: '9500-02-0008895-1950' });
+
+        expectObservable(result$).toBe('(a|)', { a: 3139914318 });
+        expect(getCachedDeviceByDeviceRefObj).toBeCalledTimes(1);
+        expect(getDevices).not.toBeCalled();
+      });
+    });
+
+    it('should update the cached devices and return device address by serial number', () => {
+      return scheduler.run(async ({ expectObservable }) => {
+        const getCachedDeviceByDeviceRefObj = jest.spyOn(request, 'getCachedDeviceByDeviceRefObj');
+        const getDevices = jest.spyOn(request, 'getDevices').mockReturnValue(of([device]));
+
+        const result$ = request.resolveDeviceAddress({ deviceSerialNumber: '9500-02-0008895-1950' });
+
+        expectObservable(result$).toBe('(a|)', { a: 3139914318 });
+        expect(getCachedDeviceByDeviceRefObj).toBeCalledTimes(1);
+        expect(getDevices).toBeCalledTimes(1);
+
+        result$.subscribe(() => {
+          expect(request.deviceMap.size).toBe(1);
+          expect(request.deviceMap.values().next().value).toBe(device);
+        });
+      });
+    });
+
+    it('should update the cached devices and throw an error when device address is not found by serial number', () => {
+      return scheduler.run(async ({ expectObservable }) => {
+        const getCachedDeviceByDeviceRefObj = jest.spyOn(request, 'getCachedDeviceByDeviceRefObj');
+        const getDevices = jest.spyOn(request, 'getDevices').mockReturnValue(of([device]));
+
+        const result$ = request.resolveDeviceAddress({ deviceSerialNumber: 'invalid-serial-number' });
+
+        expectObservable(result$).toBe('#', null, new Error('Device is not found by deviceRefObj {"deviceSerialNumber":"invalid-serial-number"}'));
+        expect(getDevices).toBeCalledTimes(1);
+
+        result$.subscribe({
+          error: () => {
+            expect(getCachedDeviceByDeviceRefObj).toBeCalledTimes(2);
+            expect(request.deviceMap.size).toBe(1);
+            expect(request.deviceMap.values().next().value).toBe(device);
+          }
+        });
+      });
+    });
+
+    xit('should update the cached devices and return device address by position', () => {
+      return scheduler.run(async ({ expectObservable }) => {
+        const getCachedDeviceByDeviceRefObj = jest.spyOn(request, 'getCachedDeviceByDeviceRefObj');
+        const getDevices = jest.spyOn(request, 'getDevices').mockReturnValue(of([device]));
+
+        const result$ = request.resolveDeviceAddress({ devicePosition: 0 });
+
+        expectObservable(result$).toBe('(a|)', { a: 3139914318 });
+        expect(getCachedDeviceByDeviceRefObj).toBeCalledTimes(1);
+        expect(getDevices).toBeCalledTimes(1);
+
+        result$.subscribe(() => {
+          expect(request.deviceMap.size).toBe(1);
+          expect(request.deviceMap.values().next().value).toBe(device);
+        });
+      });
+    });
+
+    it('should update the cached devices and throw an error when device address is not found by position', () => {
+      return scheduler.run(async ({ expectObservable }) => {
+        const getCachedDeviceByDeviceRefObj = jest.spyOn(request, 'getCachedDeviceByDeviceRefObj');
+        const getDevices = jest.spyOn(request, 'getDevices').mockReturnValue(of([device]));
+
+        const result$ = request.resolveDeviceAddress({ devicePosition: 54 });
+
+        expectObservable(result$).toBe('#', null, new Error('Device is not found by deviceRefObj {"devicePosition":54}'));
+        expect(getDevices).toBeCalledTimes(1);
+
+        result$.subscribe({
+          error: () => {
+            expect(getCachedDeviceByDeviceRefObj).toBeCalledTimes(2);
+            expect(request.deviceMap.size).toBe(1);
+            expect(request.deviceMap.values().next().value).toBe(device);
+          }
+        });
+      });
+    });
+
+    it('should clear the previously cached devices and return device address by serial number', () => {
+      return scheduler.run(async ({ expectObservable }) => {
+        request.deviceMap.set('invalid-serial-number', { deviceAddress: 1234567890, id: '9500-02-0008895-1950' });
+
+        const getCachedDeviceByDeviceRefObj = jest.spyOn(request, 'getCachedDeviceByDeviceRefObj');
+        const getDevices = jest.spyOn(request, 'getDevices').mockReturnValue(of([device]));
+
+        const result$ = request.resolveDeviceAddress({ deviceSerialNumber: '9500-02-0008895-1950' });
+
+        expectObservable(result$).toBe('(a|)', { a: 3139914318 });
+        expect(getCachedDeviceByDeviceRefObj).toBeCalledTimes(1);
+        expect(getDevices).toBeCalledTimes(1);
+
+        result$.subscribe(() => {
+          expect(request.deviceMap.size).toBe(1);
+          expect(request.deviceMap.values().next().value).toBe(device);
+        });
+      });
+    });
+  });
+
+  describe('getParameterValue', () => {
+    it('should return number value for the provided device parameter id', () => {
+      return scheduler.run(async ({ hot, expectObservable }) => {
+        const message$ = hot('a', {
+          a: {
+            "id": "682f5065-92c0-4879-b22a-599e828f5907",
+            "status": {
+              "deviceParameterValues": {
+                "parameterValues": [
+                  {
+                    "index": 8240,
+                    "subindex": 1,
+                    "intValue": 62250,
+                    "typeValue": "intValue",
+                    "success": {
+                      "code": 1,
+                      "message": ""
+                    },
+                    "status": "success"
+                  }
+                ],
+                "deviceAddress": 3139914318,
+                "progress": null
+              },
+              "type": "deviceParameterValues"
+            },
+            "type": "status"
+          }
+        });
+        Object.defineProperty(request.socket, 'message$', { value: message$ });
+
+        const mock = jest.spyOn(request, 'resolveDeviceAddress');
+        mock.mockReturnValue(of(3139914318));
+        const getDeviceParameterValues = jest.spyOn(request, 'getDeviceParameterValues')
+
+        const result$ = request.getParameterValue('0x6072:00.9500-02-0008895-1950', false, 2000, '682f5065-92c0-4879-b22a-599e828f5907');
+
+        expectObservable(result$).toBe('(a|)', { a: 62250 });
+        result$.subscribe(() => {
+          expect(getDeviceParameterValues).toBeCalledWith({
+            "deviceSerialNumber": "9500-02-0008895-1950",
+            "parameters": [{ "index": 24690, "loadFromCache": false, "subindex": 0 }],
+          }, 2000, "682f5065-92c0-4879-b22a-599e828f5907")
+        })
+      });
+    });
+
+    it('should return number value for the provided device address, index, and subindex', () => {
+      return scheduler.run(async ({ hot, expectObservable }) => {
+        const message$ = hot('a', {
+          a: {
+            "id": "682f5065-92c0-4879-b22a-599e828f5907",
+            "status": {
+              "deviceParameterValues": {
+                "parameterValues": [
+                  {
+                    "index": 8240,
+                    "subindex": 1,
+                    "intValue": 62250,
+                    "typeValue": "intValue",
+                    "success": {
+                      "code": 1,
+                      "message": ""
+                    },
+                    "status": "success"
+                  }
+                ],
+                "deviceAddress": 3139914318,
+                "progress": null
+              },
+              "type": "deviceParameterValues"
+            },
+            "type": "status"
+          }
+        });
+        Object.defineProperty(request.socket, 'message$', { value: message$ });
+
+        const mock = jest.spyOn(request, 'resolveDeviceAddress');
+        mock.mockReturnValue(of(3139914318));
+
+        const result = request.getParameterValue(3139914318, 0x6072, 0, false, 2000, '682f5065-92c0-4879-b22a-599e828f5907');
+
+        expectObservable(result).toBe('(a|)', { a: 62250 });
+      });
+    });
+
+    it('should return string value for the provided device parameter id', () => {
+      return scheduler.run(async ({ hot, expectObservable }) => {
+        const message$ = hot('a', {
+          a: {
+            "id": "682f5065-92c0-4879-b22a-599e828f5907",
+            "status": {
+              "deviceParameterValues": {
+                "parameterValues": [
+                  {
+                    "index": 4106,
+                    "subindex": 0,
+                    "stringValue": 'v5.0.6',
+                    "typeValue": "stringValue",
+                    "success": {
+                      "code": 1,
+                      "message": ""
+                    },
+                    "status": "success"
+                  }
+                ],
+                "deviceAddress": 3139914318,
+                "progress": null
+              },
+              "type": "deviceParameterValues"
+            },
+            "type": "status"
+          }
+        });
+        Object.defineProperty(request.socket, 'message$', { value: message$ });
+
+        const mock = jest.spyOn(request, 'resolveDeviceAddress');
+        mock.mockReturnValue(of(3139914318));
+
+        const result = request.getParameterValue<string>('0x100A:00.9500-02-0008895-1950', false, 2000, '682f5065-92c0-4879-b22a-599e828f5907');
+
+        expectObservable(result).toBe('(a|)', { a: 'v5.0.6' });
+      });
+    });
+
+    it('should return string value for the provided device address, index and subindex', () => {
+      return scheduler.run(async ({ hot, expectObservable }) => {
+        const message$ = hot('a', {
+          a: {
+            "id": "682f5065-92c0-4879-b22a-599e828f5907",
+            "status": {
+              "deviceParameterValues": {
+                "parameterValues": [
+                  {
+                    "index": 4106,
+                    "subindex": 0,
+                    "stringValue": 'v5.0.6',
+                    "typeValue": "stringValue",
+                    "success": {
+                      "code": 1,
+                      "message": ""
+                    },
+                    "status": "success"
+                  }
+                ],
+                "deviceAddress": 3139914318,
+                "progress": null
+              },
+              "type": "deviceParameterValues"
+            },
+            "type": "status"
+          }
+        });
+        Object.defineProperty(request.socket, 'message$', { value: message$ });
+
+        const mock = jest.spyOn(request, 'resolveDeviceAddress');
+        mock.mockReturnValue(of(3139914318));
+
+        const result = request.getParameterValue<string>(3139914318, 0x100A, 0x0, false, 2000, '682f5065-92c0-4879-b22a-599e828f5907');
+
+        expectObservable(result).toBe('(a|)', { a: 'v5.0.6' });
+      });
+    });
+
+    it('should throw an error if device parameter does not exist', () => {
+      return scheduler.run(async ({ hot, expectObservable }) => {
+        const message$ = hot('a', {
+          a: {
+            "id": "682f5065-92c0-4879-b22a-599e828f5907",
+            "status": {
+              "deviceParameterValues": {
+                "parameterValues": [
+                  {
+                    "index": 4660,
+                    "subindex": 1,
+                    "error": {
+                      "code": 1,
+                      "message": ""
+                    },
+                    "status": "error"
+                  }
+                ],
+                "deviceAddress": 3856364449,
+                "progress": null
+              },
+              "type": "deviceParameterValues"
+            },
+            "type": "status"
+          }
+        });
+        Object.defineProperty(request.socket, 'message$', { value: message$ });
+
+        const mock = jest.spyOn(request, 'resolveDeviceAddress');
+        mock.mockReturnValue(of(3139914318));
+
+        const result$ = request.getParameterValue<string>(3139914318, 0x100A, 0x0, false, 2000, '682f5065-92c0-4879-b22a-599e828f5907');
+
+        expectObservable(result$).toBe('#', null, new Error('Failed to get parameter value (NOT_FOUND) for {"deviceAddress":3139914318,"index":4106,"subindex":0,"loadFromCache":false,"requestTimeout":2000,"messageId":"682f5065-92c0-4879-b22a-599e828f5907"}'));
+      });
+    });
+
+    it('should throw an error if request times out', () => {
+      return scheduler.run(async ({ hot }) => {
+        const message$ = hot('a', {
+          a: {
+            "id": "i-will-timeout",
+            "status": {
+              "deviceParameterValues": {
+                "parameterValues": [
+                  {
+                    "index": 4660,
+                    "subindex": 1,
+                    "error": {
+                      "code": 1,
+                      "message": ""
+                    },
+                    "status": "error"
+                  }
+                ],
+                "deviceAddress": 3856364449,
+                "progress": null
+              },
+              "type": "deviceParameterValues"
+            },
+            "type": "status"
+          }
+        });
+        Object.defineProperty(request.socket, 'message$', { value: message$ });
+
+        const mock = jest.spyOn(request, 'resolveDeviceAddress');
+        mock.mockReturnValue(of(3139914318));
+
+        const result$ = request.getParameterValue<string>(3139914318, 0x100A, 0x0, false, 2000, '682f5065-92c0-4879-b22a-599e828f5907');
+
+        result$.subscribe({
+          error: (err) => {
+            expect(err.message).toBe('Timeout has occurred');
+          },
+        });
+      });
+    });
+  });
+
+  describe('getParameterValues', () => {
+    // it('should return an Observable of empty array if the props are empty', async () => {
+    //   const values = await lastValueFrom(reqResClient.getParameterValues([]));
+
+    //   expect(values).toEqual([]);
+
+    //   expect(reqResClient.socket.send).not.toBeCalled();
+    // });
+
+    it('should return an array of values for the provided device parameter ids', () => {
+      return scheduler.run(async ({ hot, expectObservable }) => {
+        const message$ = hot('a', {
+          a: {
+            "id": "99db7b72-fec6-4282-8744-3dfb3526e3ed",
+            "status": {
+              "multiDeviceParameterValues": {
+                "collection": [
+                  {
+                    "parameterValues": [
+                      {
+                        "index": 8240,
+                        "subindex": 1,
+                        "intValue": 62125,
+                        "typeValue": "intValue",
+                        "success": {
+                          "code": 1,
+                          "message": ""
+                        },
+                        "status": "success"
+                      },
+                      {
+                        "index": 8241,
+                        "subindex": 1,
+                        "intValue": 56033,
+                        "typeValue": "intValue",
+                        "success": {
+                          "code": 1,
+                          "message": ""
+                        },
+                        "status": "success"
+                      }
+                    ],
+                    "deviceAddress": 3139914318,
+                    "progress": null
+                  }
+                ]
+              },
+              "type": "multiDeviceParameterValues"
+            },
+            "type": "status"
+          }
+        });
+        Object.defineProperty(request.socket, 'message$', { value: message$ });
+
+        const mock = jest.spyOn(request, 'resolveDeviceAddress');
+        mock.mockReturnValue(of(3139914318));
+
+        const result = request.getParameterValues([
+          '0x6072:00.9500-02-0008895-1950',
+          '0x6073:00.9500-02-0008895-1950',
+        ], false, 2000, '99db7b72-fec6-4282-8744-3dfb3526e3ed');
+
+        expectObservable(result).toBe('(r|)', {
+          r: [62125, 56033],
+        });
+      });
+    });
+  });
+
+  describe('setParameterValue', () => {
+    it('should set device parameter value', () => {
+      return scheduler.run(async ({ hot, expectObservable }) => {
+        const message$ = hot('a', {
+          a: {
+            "id": "bf1abc47-85e9-4c07-bc02-c41227cb7cef",
+            "status": {
+              "deviceParameterValues": {
+                "parameterValues": [
+                  {
+                    "index": 24693,
+                    "subindex": 0,
+                    "intValue": 323,
+                    "typeValue": "intValue",
+                    "success": {
+                      "code": 2,
+                      "message": ""
+                    },
+                    "status": "success"
+                  }
+                ],
+                "deviceAddress": 3856364449,
+                "progress": null
+              },
+              "type": "deviceParameterValues"
+            },
+            "type": "status"
+          }
+        });
+        Object.defineProperty(request.socket, 'message$', { value: message$ });
+
+        const resolveDeviceAddress = jest.spyOn(request, 'resolveDeviceAddress');
+        resolveDeviceAddress.mockReturnValue(of(3139914318));
+        const setDeviceParameterValues = jest.spyOn(request, 'setDeviceParameterValues');
+
+        const result$ = request.setParameterValue('0x6075:00.9500-02-0008895-1950', 6000, 'intValue', 1000, 'bf1abc47-85e9-4c07-bc02-c41227cb7cef');
+
+        expectObservable(result$).toBe('(a|)', { a: undefined });
+        result$.subscribe(() => {
+          expect(setDeviceParameterValues).toBeCalledWith({
+            "deviceSerialNumber": "9500-02-0008895-1950",
+            "parameterValues": [{ "index": 24693, "intValue": 6000, "subindex": 0 }],
+          }, 1000, "bf1abc47-85e9-4c07-bc02-c41227cb7cef");
+        })
+      });
+    });
+
+    it('should thrown an error when parameter does not change', () => {
+      return scheduler.run(async ({ hot, expectObservable }) => {
+        const message$ = hot('a', {
+          a: {
+            "id": "bf1abc47-85e9-4c07-bc02-c41227cb7cef",
+            "status": {
+              "deviceParameterValues": {
+                "parameterValues": [
+                  {
+                    "index": 8240,
+                    "subindex": 1,
+                    "intValue": 61875,
+                    "typeValue": "intValue",
+                    "error": {
+                      "code": 3,
+                      "message": ""
+                    },
+                    "status": "error"
+                  }
+                ],
+                "deviceAddress": 3856364449,
+                "progress": null
+              },
+              "type": "deviceParameterValues"
+            },
+            "type": "status"
+          }
+        });
+        Object.defineProperty(request.socket, 'message$', { value: message$ });
+
+        const resolveDeviceAddress = jest.spyOn(request, 'resolveDeviceAddress');
+        resolveDeviceAddress.mockReturnValue(of(3139914318));
+        // const setDeviceParameterValues = jest.spyOn(request, 'setDeviceParameterValues');
+
+        const result$ = request.setParameterValue('0x6075:00.9500-02-0008895-1950', 6000, 'intValue', 1000, 'bf1abc47-85e9-4c07-bc02-c41227cb7cef');
+
+        expectObservable(result$).toBe('#', null, new Error('Failed to set parameter value (NOT_CHANGED) for {"deviceSerialNumber":"9500-02-0008895-1950","index":24693,"subindex":0,"value":6000,"valueTypeKey":"intValue","requestTimeout":1000,"messageId":"bf1abc47-85e9-4c07-bc02-c41227cb7cef"}'));
+      });
+    });
+  });
+
+  // describe('setParameterValues', () => {
+  //   it('should do nothing if values array is empty', () => {
+  //     reqResClient.setParameterValues([]);
+
+  //     expect(reqResClient.socket.send).not.toBeCalled();
+  //   });
+
+  //   fit('should set parameter values when values is an array of objects that map device parameter id to value', async () => {
+  //     return testScheduler.run(async ({ hot }) => {
+  //       const message$ = hot('a', {
+  //         a: {
+  //           "id": "setMultiDeviceParameterValuesMessageId",
+  //           "status": {
+  //             "multiDeviceParameterValues": {
+  //               "collection": [
+  //                 {
+  //                   "parameterValues": [
+  //                     {
+  //                       "index": 24690,
+  //                       "subindex": 0,
+  //                       "uintValue": 2000,
+  //                       "typeValue": "uintValue",
+  //                       "success": {
+  //                         "code": 2,
+  //                         "message": ""
+  //                       },
+  //                       "status": "success"
+  //                     }
+  //                   ],
+  //                   "deviceAddress": 1234567890,
+  //                   "progress": null
+  //                 },
+  //                 {
+  //                   "parameterValues": [
+  //                     {
+  //                       "index": 24691,
+  //                       "subindex": 0,
+  //                       "uintValue": 1000,
+  //                       "typeValue": "uintValue",
+  //                       "success": {
+  //                         "code": 2,
+  //                         "message": ""
+  //                       },
+  //                       "status": "success"
+  //                     }
+  //                   ],
+  //                   "deviceAddress": 1234567890,
+  //                   "progress": null
+  //                 }
+  //               ]
+  //             },
+  //             "type": "multiDeviceParameterValues"
+  //           },
+  //           "type": "status"
+  //         },
+  //       });
+  //       Object.defineProperty(reqResClient.socket, 'message$', { value: message$ });
+
+  //       const mock = jest.spyOn(reqResClient, 'resolveDeviceAddress');
+  //       mock.mockReturnValue(Promise.resolve(3139914318));
+
+  //       reqResClient.parameterTypeValueKeyMap.set(3139914318,
+  //         new Map([['0x6072:00', 'uintValue'], ['0x6073:00', 'uintValue']]))
+
+  //       await reqResClient.setParameterValues({
+  //         '0x6072:00.9500-02-0008895-1950': 2000,
+  //         '0x6073:00.9500-02-0008895-1950': 1000,
+  //       }, 3000, 'setMultiDeviceParameterValuesMessageId');
+
+  //       expect(reqResClient.socket.send).toBeCalledTimes(1);
+  //       expect(reqResClient.socket.send).toBeCalledWith({
+  //         id: 'setMultiDeviceParameterValuesMessageId',
+  //         request: {
+  //           setMultiDeviceParameterValues: {
+  //             collection: [
+  //               {
+  //                 deviceAddress: 3139914318,
+  //                 parameterValues: [
+  //                   { index: 24690, subindex: 0, uintValue: 2000 },
+  //                   { index: 24691, subindex: 0, uintValue: 1000 },
+  //                 ]
+  //               }
+  //             ],
+  //           },
+  //         },
+  //       });
+
+  //       return;
+  //     });
+  //   });
+  // });
+
+});