motion-master-client 0.0.3 → 0.0.6

package/src/lib/motion-master-pub-sub-web-socket.ts

@@ -1,71 +0,0 @@
-import { BehaviorSubject, Subject } from "rxjs";
-import { webSocket, WebSocketSubject, WebSocketSubjectConfig } from "rxjs/webSocket";
-import { logger } from "./logger";
-import { MotionMasterPubSubSocket } from "./motion-master-pub-sub-socket";
-import { MotionMasterMessage } from "./types";
-
-export class MotionMasterPubSubWebSocket implements MotionMasterPubSubSocket {
-
-  readonly opened$ = new BehaviorSubject<boolean>(false);
-
-  readonly data$ = new Subject<[string, MotionMasterMessage]>();
-
-  private webSocket$?: WebSocketSubject<[string, MotionMasterMessage]>;
-
-  private _url?: string;
-
-  get url(): string | undefined {
-    return this._url;
-  }
-
-  open(url: string): void {
-    if (this.opened$.getValue() === true) {
-      throw new Error('MotionMasterPubSubWebSocket is already opened!');
-    }
-
-    this._url = url;
-
-    this.webSocket$ = this.createWebSocket(url);
-
-    this.webSocket$.subscribe({
-      next: (value) => this.data$.next(value),
-      error: () => {
-        // ignore
-      },
-    });
-  }
-
-  close(): void {
-    this.webSocket$?.unsubscribe();
-  }
-
-  private createWebSocket(url: string) {
-    const decoder = new TextDecoder('utf-8');
-
-    const webSocketConfig: WebSocketSubjectConfig<[string, MotionMasterMessage]> = {
-      binaryType: 'arraybuffer',
-      closeObserver: {
-        next: () => {
-          this.opened$.next(false);
-          logger.info(`Connection closed ${url}`);
-        },
-      },
-      deserializer: (e: MessageEvent<ArrayBuffer>): [string, MotionMasterMessage] => {
-        const end = new Uint8Array(e.data, 0, 1)[0] + 1;
-        const topic = decoder.decode(e.data.slice(1, end)); // topic starts from the 2nd byte
-        const message = MotionMasterMessage.decode(new Uint8Array(e.data.slice(end)));
-        return [topic, message];
-      },
-      openObserver: {
-        next: () => {
-          this.opened$.next(true);
-          logger.info(`Connection opened ${url}`);
-        },
-      },
-      url,
-    };
-
-    return webSocket(webSocketConfig);
-  }
-
-}

package/src/lib/motion-master-pub-sub-worker-socket.ts

@@ -1,58 +0,0 @@
-import { BehaviorSubject, Subject } from "rxjs";
-import { logger } from "./logger";
-import { MotionMasterPubSubSocket } from "./motion-master-pub-sub-socket";
-import { selectMotionMasterMessageByTopic, selectMotionMasterMessageStatusByKey } from "./operators";
-import { MotionMasterMessage } from "./types";
-
-export class MotionMasterPubSubWorkerSocket implements MotionMasterPubSubSocket {
-
-  opened$ = new BehaviorSubject(false);
-
-  data$ = new Subject<[string, MotionMasterMessage]>();
-
-  readonly notification$ = this.data$.pipe(
-    selectMotionMasterMessageByTopic('notification'),
-  );
-
-  readonly systemEvent$ = this.notification$.pipe(
-    selectMotionMasterMessageStatusByKey<MotionMasterMessage.Status.SystemEvent>('systemEvent'),
-  );
-
-  readonly deviceEvent$ = this.notification$.pipe(
-    selectMotionMasterMessageStatusByKey<MotionMasterMessage.Status.DeviceEvent>('deviceEvent'),
-  );
-
-  private _url?: string;
-
-  constructor(
-    public readonly worker: Worker,
-  ) { }
-
-  get url(): string | undefined {
-    return this._url;
-  }
-
-  open(url: string): void {
-    this._url = url;
-
-    this.worker.onmessage = ({ data }) => {
-      if ('opened' in data) {
-        const { opened } = data;
-        this.opened$.next(opened);
-        logger.info(opened ? `Opened pub/sub 🔌 ${url}` : `Closed pub/sub 🔌 ${url}`);
-      } else if ('topic' in data) {
-        const { topic, messages }: { topic: string, messages: MotionMasterMessage[] } = data;
-        messages.forEach((message) => this.data$.next([topic, message]));
-      }
-    }
-
-    this.worker.postMessage({
-      open: { url }
-    });
-  }
-
-  close(): void {
-    this.worker.postMessage({ close: true })
-  }
-
-}

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

@@ -1,126 +0,0 @@
-import { TestScheduler } from "rxjs/testing";
-import { MotionMasterReqResClient } from "./motion-master-req-res-client";
-import { MotionMasterReqResSocket } from "./motion-master-req-res-socket";
-
-describe('MotionMasterReqResClient', () => {
-
-  let reqResClient: MotionMasterReqResClient;
-  let testScheduler: TestScheduler;
-
-  beforeEach(() => {
-    const socket = jest.fn() as unknown as MotionMasterReqResSocket;
-    socket.send = jest.fn();
-    reqResClient = new MotionMasterReqResClient(socket);
-
-    testScheduler = new TestScheduler((actual, expected) => {
-      return expect(actual).toEqual(expected);
-    });
-  });
-
-  describe('pingSystem', () => {
-    it('should send PingSystem request message and return EMPTY observable', (done) => {
-      testScheduler.run(({ expectObservable }) => {
-        const result = reqResClient.pingSystem('pingSystemMessageId');
-
-        expect(reqResClient.socket.send).toBeCalledTimes(1);
-        expect(reqResClient.socket.send).toBeCalledWith({
-          id: 'pingSystemMessageId',
-          request: {
-            pingSystem: {},
-          },
-        });
-        expectObservable(result).toBe('|');
-
-        done();
-      });
-    });
-  });
-
-  describe('pingSystemAsync', () => {
-    it('should send PingSystem request message and return a promise of undefined', async () => {
-      const result = await reqResClient.pingSystemAsync('pingSystemAsyncMessageId');
-
-      expect(reqResClient.socket.send).toBeCalledTimes(1);
-      expect(reqResClient.socket.send).toBeCalledWith({
-        id: 'pingSystemAsyncMessageId',
-        request: {
-          pingSystem: {},
-        },
-      });
-      expect(result).toBeUndefined();
-    });
-  });
-
-  describe('getSystemVersion', () => {
-    it('should send GetSystemVersion request message and return an observable of SystemVersion status', (done) => {
-      testScheduler.run(({ hot, expectObservable }) => {
-        const message$ = hot('a', {
-          a: {
-            "id": "getSystemVersionMessageId",
-            "status": {
-              "systemVersion": {
-                "version": "4.8.4"
-              },
-              "type": "systemVersion"
-            },
-            "type": "status"
-          }
-        });
-        Object.defineProperty(reqResClient.socket, 'message$', { value: message$ });
-
-        const result = reqResClient.getSystemVersion(1000, 'getSystemVersionMessageId');
-
-        expect(reqResClient.socket.send).toBeCalledTimes(1);
-        expect(reqResClient.socket.send).toBeCalledWith({
-          id: 'getSystemVersionMessageId',
-          request: {
-            getSystemVersion: {},
-          },
-        });
-        expectObservable(result).toBe('(s|)', {
-          s: {
-            version: '4.8.4',
-            request: 'succeeded',
-            messageId: 'getSystemVersionMessageId'
-          }
-        });
-
-        done();
-      });
-    });
-  });
-
-  describe('getSystemVersionAsync', () => {
-    it('should send GetSystemVersion request message and return a promise of version', (done) => {
-      testScheduler.run(({ hot }) => {
-        const message$ = hot('a', {
-          a: {
-            "id": "getSystemVersionAsyncMessageId",
-            "status": {
-              "systemVersion": {
-                "version": "4.8.4"
-              },
-              "type": "systemVersion"
-            },
-            "type": "status"
-          }
-        });
-        Object.defineProperty(reqResClient.socket, 'message$', { value: message$ });
-
-        reqResClient.getSystemVersionAsync(1000, 'getSystemVersionAsyncMessageId').then((result) => {
-          expect(reqResClient.socket.send).toBeCalledTimes(1);
-          expect(reqResClient.socket.send).toBeCalledWith({
-            id: 'getSystemVersionAsyncMessageId',
-            request: {
-              getSystemVersion: {},
-            },
-          });
-          expect(result).toBe('4.8.4');
-
-          done();
-        });
-      });
-    });
-  });
-
-});