jp.ms.common.engine 1.0.20 → 2.0.0

package/src/tests/just-black-jack/tests/black-jack-simple-room.test.ts

@@ -2,83 +2,400 @@ import { cloneDeep } from 'lodash';
 
 import { BlackJackPlayer } from '../domain/black-jack-player';
 import { BlackJackSimpleRoom } from '../rooms/black-jack-simple-room';
-
-import { mockDeck, player1, player2 } from './common';
 import { calculateResult } from '../helpers/calculate-result';
 import { GameRoomConfig } from '../../../base';
-import { BlackJackGameMaster, BlackJackGameStateType } from '../domain/black-jack-game-master';
+import { BlackJackGameMaster } from '../domain/black-jack-game-master';
+import { MinPlayersStartStrategy } from '../../../strategies';
+import { NotActivePlayerMoveException } from '../../../exceptions';
+import { BlackJackMoveData } from '../domain/black-jack-move-data';
+import { BlackJackPlayerActionsEnum } from '../domain/black-jack-player-actions.enum';
+
+import { mockDeck, player1, player2 } from './common';
 
 describe('black jack simple room', () => {
-  let newPlayer1: BlackJackPlayer;
-  let newPlayer2: BlackJackPlayer;
-
-  let cashRoomConfig: GameRoomConfig = {
-    id: '1',
-    gameType: 'JUST_BLACK_JACK',
-    roomType: 'simple',
-    rulesType: 'STANDARD',
-    maxPlayers: 6,
-    bet: 10,
-    title: {
-      ru: 'Волга 2 000 / {{NUMBER}}',
-      en: 'Volga 2,000 / {{NUMBER}}'
-    },
-    subtitle: {
-      ru: 'Ставки - {{HALF_BET}} / {{BET}}',
-      en: 'Bet - {{HALF_BET}} / {{BET}}'
-    },
-    turnTimeout: 0,
-    restartTimeout: 0,
-  };
-
-  beforeAll(() => {
-    mockDeck();
-  });
-
-  beforeEach(() => {
-    newPlayer1 = cloneDeep(player1);
-    newPlayer2 = cloneDeep(player2);
-  });
-
-  it('black jack simple room', () => {
-    const room = new BlackJackSimpleRoom(cashRoomConfig);
-    room.addMaster();
-
-    const master = room.getMasters()[0] as BlackJackGameMaster | undefined;
-    const table1 = master.getTable();
-    const dealer = master.getDealer();
-
-    if (table1) {
-      table1.addPlayerToSeat(newPlayer1);
-      newPlayer1.setStack(100);
-
-      table1.addPlayerToSeat(newPlayer2);
-      newPlayer2.setStack(100);
-
-      expect(master.getGameRound()?.getState()).toBeUndefined();
-
-      master.startNewRound();
-
-      expect(master.getGameRoundState().isInProgress()).toBeTruthy();
-      expect(table1.getPlayers().length).toBe(3);
-
-      expect(master.getGameRound()?.getActivePlayer()).toBe(newPlayer1);
-      expect(calculateResult(newPlayer1.getCards())).toBe(20);
-
-      master.finishMove(newPlayer1);
-
-      expect(master.getGameRound()?.getActivePlayer()).toBe(newPlayer2);
-      expect(calculateResult(newPlayer2.getCards())).toBe(19);
-
-      master.getCard(newPlayer2);
-      expect(calculateResult(newPlayer2.getCards())).toBe(27);
-      master.finishMove(newPlayer2);
-
-      expect(master.getGameRound()?.getActivePlayer()).toBe(dealer);
-      expect(calculateResult(master.getDealer()?.getCards() ?? [])).toBe(21);
-      master.finishMove(dealer);
-
-      expect(master.getGameRoundState().isFinish()).toBeTruthy();
-    }
-  });
+    let newPlayer1: BlackJackPlayer;
+    let newPlayer2: BlackJackPlayer;
+
+    let cashRoomConfig: GameRoomConfig = {
+        id: '1',
+        gameType: 'JUST_BLACK_JACK',
+        roomType: 'simple',
+        rulesType: 'STANDARD',
+        maxPlayers: 6,
+        bet: 10,
+        ticketPrice: 500,
+        title: {
+            ru: 'Волга 2 000 / {{NUMBER}}',
+            en: 'Volga 2,000 / {{NUMBER}}'
+        },
+        subtitle: {
+            ru: 'Ставки - {{HALF_BET}} / {{BET}}',
+            en: 'Bet - {{HALF_BET}} / {{BET}}'
+        },
+        turnTimeout: 0,
+        restartTimeout: 0,
+        localeService: { t: () => '' },
+        startStrategy: new MinPlayersStartStrategy(),
+    };
+
+    beforeAll(() => {
+        mockDeck();
+    });
+
+    beforeEach(() => {
+        newPlayer1 = cloneDeep(player1);
+        newPlayer2 = cloneDeep(player2);
+    });
+
+    it('black jack simple room', () => {
+        const room = new BlackJackSimpleRoom(cashRoomConfig);
+        room.addMaster();
+
+        const master = room.getMasters()[0] as BlackJackGameMaster | undefined;
+        const table1 = master?.getTable();
+        const dealer = master?.getDealer();
+
+        if (table1 && master && dealer) {
+            expect(master.getGameRound()?.getState().isWaiting()).toBe;
+
+            master.enterTheTable(newPlayer1);
+            newPlayer1.stack = 100;
+
+            expect(master.getGameRound()?.getState().isInProgress()).toBeTruthy();
+            expect(table1.getPlayers().length).toBe(2);
+
+            expect(master.getGameRound()?.getActivePlayer()).toBe(newPlayer1);
+            expect(calculateResult(newPlayer1.getCards())).toBe(20);
+
+            master.moveOnTheTable(newPlayer1, new BlackJackMoveData(BlackJackPlayerActionsEnum.FINISH_MOVE, ''));
+
+            expect(master.getGameRound()?.getActivePlayer()).toBe(dealer);
+            expect(calculateResult(master.getDealer()?.getCards() ?? [])).toBe(21);
+            master.moveOnTheTable(dealer, new BlackJackMoveData(BlackJackPlayerActionsEnum.FINISH_MOVE, ''));
+
+            expect(master.getGameRound()?.getState().isFinish()).toBeTruthy();
+        }
+    });
+
+    it('black jack finish', () => {
+        const room = new BlackJackSimpleRoom(cashRoomConfig);
+        room.addMaster();
+
+        const master = room.getMasters()[0] as BlackJackGameMaster | undefined;
+        const table1 = master?.getTable();
+        const dealer = master?.getDealer();
+
+        if (table1 && master && dealer) {
+            expect(master.getGameRound()?.getState()).toBeUndefined();
+
+            master.enterTheTable(newPlayer1);
+            newPlayer1.stack = 100;
+
+            expect(master.getGameRound()?.getState().isInProgress()).toBeTruthy();
+
+            master.exitTheTable(newPlayer1);
+
+            expect(master.getGameRound()?.getState().isFinish()).toBeTruthy();
+        }
+    });
+
+    it('black jack restart', () => {
+        jest.useFakeTimers();
+
+        const room = new BlackJackSimpleRoom({ ...cashRoomConfig, restartTimeout: 10 });
+        room.addMaster();
+
+        const master = room.getMasters()[0] as BlackJackGameMaster | undefined;
+        const table1 = master?.getTable();
+        const dealer = master?.getDealer();
+
+        if (table1 && master && dealer) {
+            expect(master.getGameRound()?.getState()).toBeUndefined();
+
+            master.enterTheTable(newPlayer1);
+            newPlayer1.stack = 100;
+
+            expect(master.getGameRound()?.getState().isInProgress()).toBeTruthy();
+            expect(table1.getPlayers().length).toBe(2);
+
+            expect(master.getGameRound()?.getActivePlayer()).toBe(newPlayer1);
+            expect(calculateResult(newPlayer1.getCards())).toBe(20);
+
+            master.moveOnTheTable(newPlayer1, new BlackJackMoveData(BlackJackPlayerActionsEnum.FINISH_MOVE, ''));
+
+            expect(master.getGameRound()?.getActivePlayer()).toBe(dealer);
+            expect(calculateResult(master.getDealer()?.getCards() ?? [])).toBe(21);
+            master.moveOnTheTable(dealer, new BlackJackMoveData(BlackJackPlayerActionsEnum.FINISH_MOVE, ''));
+
+            expect(master.getGameRound()?.getState().isFinish()).toBeTruthy();
+
+            jest.runOnlyPendingTimers();
+
+            expect(master.getGameRound()?.getState().isInProgress()).toBeTruthy();
+        }
+    });
+
+    it('black jack restart to wait', () => {
+        jest.useFakeTimers();
+
+        const room = new BlackJackSimpleRoom({ ...cashRoomConfig, restartTimeout: 10 });
+        room.addMaster();
+
+        const master = room.getMasters()[0] as BlackJackGameMaster | undefined;
+        const table1 = master?.getTable();
+        const dealer = master?.getDealer();
+
+        if (table1 && master && dealer) {
+            expect(master.getGameRound()?.getState()).toBeUndefined();
+
+            master.enterTheTable(newPlayer1);
+            newPlayer1.stack = 100;
+
+            expect(master.getGameRound()?.getState().isInProgress()).toBeTruthy();
+            expect(table1.getPlayers().length).toBe(2);
+
+            expect(master.getGameRound()?.getActivePlayer()).toBe(newPlayer1);
+            expect(calculateResult(newPlayer1.getCards())).toBe(20);
+
+            master.moveOnTheTable(newPlayer1, new BlackJackMoveData(BlackJackPlayerActionsEnum.FINISH_MOVE, ''));
+
+            expect(master.getGameRound()?.getActivePlayer()).toBe(dealer);
+            expect(calculateResult(master.getDealer()?.getCards() ?? [])).toBe(21);
+            master.moveOnTheTable(dealer, new BlackJackMoveData(BlackJackPlayerActionsEnum.FINISH_MOVE, ''));
+
+            expect(master.getGameRound()?.getState().isFinish()).toBeTruthy();
+
+            master.exitTheTable(newPlayer1);
+
+            jest.runOnlyPendingTimers();
+
+            expect(master.getGameRound()?.getState()).toBeUndefined();
+        }
+    });
+
+    it('black jack move not active', () => {
+        const room = new BlackJackSimpleRoom(cashRoomConfig);
+        room.addMaster();
+
+        const master = room.getMasters()[0] as BlackJackGameMaster | undefined;
+        const table1 = master?.getTable();
+        const dealer = master?.getDealer();
+
+        if (table1 && master && dealer) {
+            expect(master.getGameRound()?.getState()).toBeUndefined();
+
+            master.enterTheTable(newPlayer1);
+            newPlayer1.stack = 100;
+
+            expect(master.getGameRound()?.getActivePlayer()).toBe(newPlayer1);
+
+            expect(master.getGameRound()?.getState().isInProgress()).toBeTruthy();
+
+            expect(() => master.moveOnTheTable(dealer, new BlackJackMoveData(BlackJackPlayerActionsEnum.FINISH_MOVE, '')))
+                .toThrow(NotActivePlayerMoveException);
+        }
+    });
+
+    it('black jack, 1 not active, kick and finish', () => {
+        jest.useFakeTimers();
+
+        const room = new BlackJackSimpleRoom({ ...cashRoomConfig, turnTimeout: 20 });
+        room.addMaster();
+
+        const master = room.getMasters()[0] as BlackJackGameMaster | undefined;
+        const table1 = master?.getTable();
+        const dealer = master?.getDealer();
+
+        if (table1 && master && dealer) {
+            expect(master.getGameRound()?.getState()).toBeUndefined();
+
+            master.enterTheTable(newPlayer1);
+            newPlayer1.stack = 100;
+
+            expect(master.getGameRound()?.getState().isInProgress()).toBeTruthy();
+
+            jest.runOnlyPendingTimers();
+
+            expect(table1.getPlayers().length).toBe(1);
+
+            expect(table1.getPlayers()[0]).toBe(dealer);
+
+            expect(master.getGameRound()?.getState().isFinish()).toBeTruthy();
+        }
+    });
+
+    it('black jack, 1 player move', () => {
+        jest.useFakeTimers();
+
+        const room = new BlackJackSimpleRoom({ ...cashRoomConfig, turnTimeout: 20 });
+        room.addMaster();
+
+        const master = room.getMasters()[0] as BlackJackGameMaster | undefined;
+        const table1 = master?.getTable();
+        const dealer = master?.getDealer();
+
+        if (table1 && master && dealer) {
+            expect(master.getGameRound()?.getState()).toBeUndefined();
+
+            master.enterTheTable(newPlayer1);
+            newPlayer1.stack = 100;
+
+            expect(table1.getPlayers().length).toBe(2);
+
+            expect(master.getGameRound()?.getState().isInProgress()).toBeTruthy();
+
+            master.moveOnTheTable(newPlayer1, new BlackJackMoveData(BlackJackPlayerActionsEnum.FINISH_MOVE, ''));
+
+            expect(master.getGameRound()?.getActivePlayer()).toBe(dealer);
+
+            jest.runOnlyPendingTimers();
+
+            expect(table1.getPlayers().length).toBe(1);
+            expect(table1.getPlayers()[0]).toBe(newPlayer1);
+            expect(master.getGameRound()?.getState().isFinish()).toBeTruthy();
+        }
+    });
+
+    it('black jack restart, 3 player, move from queue', () => {
+        jest.useFakeTimers();
+
+        const room = new BlackJackSimpleRoom({ ...cashRoomConfig, restartTimeout: 10 });
+        room.addMaster();
+
+        const master = room.getMasters()[0] as BlackJackGameMaster | undefined;
+        const table1 = master?.getTable();
+        const dealer = master?.getDealer();
+
+        if (table1 && master && dealer) {
+            expect(master.getGameRound()?.getState()).toBeUndefined();
+
+            master.enterTheTable(newPlayer1);
+            newPlayer1.stack = 100;
+
+            expect(master.getGameRound()?.getState().isInProgress()).toBeTruthy();
+
+            master.enterTheTable(newPlayer2);
+            newPlayer2.stack = 100;
+
+            expect(table1.getPlayers().length).toBe(2);
+            expect(table1.getTableQueue().length).toBe(1);
+
+            expect(master.getGameRound()?.getActivePlayer()).toBe(newPlayer1);
+            expect(calculateResult(newPlayer1.getCards())).toBe(20);
+
+            master.moveOnTheTable(newPlayer1, new BlackJackMoveData(BlackJackPlayerActionsEnum.FINISH_MOVE, ''));
+
+            expect(master.getGameRound()?.getActivePlayer()).toBe(dealer);
+            expect(calculateResult(master.getDealer()?.getCards() ?? [])).toBe(21);
+            master.moveOnTheTable(dealer, new BlackJackMoveData(BlackJackPlayerActionsEnum.FINISH_MOVE, ''));
+
+            expect(master.getGameRound()?.getState().isFinish()).toBeTruthy();
+
+            jest.runOnlyPendingTimers();
+
+            expect(master.getGameRound()?.getState().isInProgress()).toBeTruthy();
+            expect(table1.getPlayers().length).toBe(3);
+            expect(table1.getTableQueue().length).toBe(0);
+        }
+    });
+
+    it('black jack, 3 player, active exit', () => {
+        jest.useFakeTimers();
+
+        const room = new BlackJackSimpleRoom({ ...cashRoomConfig, restartTimeout: 10 });
+        room.addMaster();
+
+        const master = room.getMasters()[0] as BlackJackGameMaster | undefined;
+        const table1 = master?.getTable();
+        const dealer = master?.getDealer();
+
+        if (table1 && master && dealer) {
+            expect(master.getGameRound()?.getState()).toBeUndefined();
+
+            master.enterTheTable(newPlayer1);
+            newPlayer1.stack = 100;
+
+            expect(master.getGameRound()?.getState().isInProgress()).toBeTruthy();
+
+            master.enterTheTable(newPlayer2);
+            newPlayer2.stack = 100;
+
+            expect(table1.getPlayers().length).toBe(2);
+            expect(table1.getExitedPlayers().length).toBe(0);
+
+            expect(master.getGameRound()?.getActivePlayer()).toBe(newPlayer1);
+            expect(calculateResult(newPlayer1.getCards())).toBe(20);
+
+            master.moveOnTheTable(newPlayer1, new BlackJackMoveData(BlackJackPlayerActionsEnum.FINISH_MOVE, ''));
+
+            expect(master.getGameRound()?.getActivePlayer()).toBe(dealer);
+            expect(calculateResult(master.getDealer()?.getCards() ?? [])).toBe(21);
+            master.moveOnTheTable(dealer, new BlackJackMoveData(BlackJackPlayerActionsEnum.FINISH_MOVE, ''));
+
+            expect(master.getGameRound()?.getState().isFinish()).toBeTruthy();
+
+            jest.runOnlyPendingTimers();
+
+            expect(master.getGameRound()?.getState().isInProgress()).toBeTruthy();
+            expect(table1.getPlayers().length).toBe(3);
+
+            expect(master.getGameRound()?.getActivePlayer()).toBe(newPlayer1);
+
+            master.exitTheTable(newPlayer1);
+            expect(table1.getPlayers().length).toBe(2);
+            expect(table1.getExitedPlayers().length).toBe(1);
+
+            expect(master.getGameRound()?.getActivePlayer()).toBe(newPlayer2);
+        }
+    });
+
+    it('black jack, 3 player, active kicked out', () => {
+        jest.useFakeTimers();
+
+        const room = new BlackJackSimpleRoom({ ...cashRoomConfig, restartTimeout: 10, turnTimeout: 20 });
+        room.addMaster();
+
+        const master = room.getMasters()[0] as BlackJackGameMaster | undefined;
+        const table1 = master?.getTable();
+        const dealer = master?.getDealer();
+
+        if (table1 && master && dealer) {
+            expect(master.getGameRound()?.getState()).toBeUndefined();
+
+            master.enterTheTable(newPlayer1);
+            newPlayer1.stack = 100;
+
+            expect(master.getGameRound()?.getState().isInProgress()).toBeTruthy();
+
+            master.enterTheTable(newPlayer2);
+            newPlayer2.stack = 100;
+
+            expect(table1.getPlayers().length).toBe(2);
+
+            expect(master.getGameRound()?.getActivePlayer()).toBe(newPlayer1);
+            expect(calculateResult(newPlayer1.getCards())).toBe(20);
+
+            master.moveOnTheTable(newPlayer1, new BlackJackMoveData(BlackJackPlayerActionsEnum.FINISH_MOVE, ''));
+
+            expect(master.getGameRound()?.getActivePlayer()).toBe(dealer);
+            expect(calculateResult(master.getDealer()?.getCards() ?? [])).toBe(21);
+            master.moveOnTheTable(dealer, new BlackJackMoveData(BlackJackPlayerActionsEnum.FINISH_MOVE, ''));
+
+            expect(master.getGameRound()?.getState().isFinish()).toBeTruthy();
+
+            jest.runOnlyPendingTimers();
+
+            expect(master.getGameRound()?.getState().isInProgress()).toBeTruthy();
+            expect(table1.getPlayers().length).toBe(3);
+
+            expect(master.getGameRound()?.getActivePlayer()).toBe(newPlayer1);
+
+            jest.runOnlyPendingTimers();
+
+            expect(table1.getPlayers().length).toBe(2);
+
+            expect(master.getGameRound()?.getActivePlayer()).toBe(newPlayer2);
+        }
+    });
+
 });

package/src/tests/just-black-jack/tests/common.ts

@@ -1,63 +1,27 @@
 import { BlackJackPlayer } from '../domain/black-jack-player';
 import * as shuffle from '../../../utils/shuffle';
 
-export const player1 = new BlackJackPlayer(
-  '5ef77417f471c39c885d18f5',
-  'dima',
-  '',
-  1000,
-);
-
-export const player2 = new BlackJackPlayer(
-  '5ef774a71486d104736561a4',
-  'vova',
-  '',
-  500,
-);
-
-export const player3 = new BlackJackPlayer(
-  '5ef774a71486d104736561a5',
-  'pasha',
-  '',
-  500,
-);
-
-export const player4 = new BlackJackPlayer(
-  '5ef774a71486d104736561a7',
-  'petya',
-  '',
-  500,
-);
-
-export const player5 = new BlackJackPlayer(
-  '5ef774a71486d104736561a8',
-  'dima 2',
-  '',
-  500,
-);
-
-export const player6 = new BlackJackPlayer(
-  '5ef774a71486d104736561a9',
-  'vova 2',
-  '',
-  500,
-);
-
-export const player7 = new BlackJackPlayer(
-  '5ef774a71486d104736561a10',
-  'pasha 2',
-  '',
-  500,
-);
-
-export const player8 = new BlackJackPlayer(
-  '5ef774a71486d104736561a11',
-  'petya 2',
-  '',
-  500,
-);
+export const player1 = new BlackJackPlayer({
+    id: '5ef77417f471c39c885d18f5',
+    fullName: 'dima',
+    avatarUrl: '',
+    balance: 1000,
+    level: 1,
+    experience: 0,
+    language: 'ru',
+});
+
+export const player2 = new BlackJackPlayer({
+    id: '5ef774a71486d104736561a4',
+    fullName: 'vova',
+    avatarUrl: '',
+    balance: 500,
+    level: 1,
+    experience: 0,
+    language: 'ru',
+});
 
 
 export function mockDeck () {
-  jest.spyOn(shuffle, 'superShuffle').mockImplementation((collection: any[]) => collection);
+    jest.spyOn(shuffle, 'superShuffle').mockImplementation((collection: any[]) => collection);
 }

package/src/utils/circle-list.ts

@@ -1,27 +1,19 @@
 import { slice } from 'lodash';
 
-export class CircleListNode<T> {
-    private data: T;
-    private next: CircleListNode<T> | null;
-    private prev: CircleListNode<T> | null;
+export abstract class CircleListNode {
+    private next: CircleListNode | null;
+    private prev: CircleListNode | null;
 
-    constructor (data: T) {
-        this.data = data;
-    }
-
-    getData () {
-        return this.data;
-    }
-
-    setData (data: T) {
-        this.data = data;
+    protected constructor () {
+        this.next = null;
+        this.prev = null;
     }
 
-    getNext () {
-        return this.next;
+    getNext<T extends CircleListNode> () {
+        return this.next as T;
     }
 
-    setNext (node: CircleListNode<T>) {
+    setNext (node: CircleListNode) {
         this.next = node;
     }
 
@@ -29,11 +21,11 @@ export class CircleListNode<T> {
         this.next = null;
     }
 
-    getPrev () {
-        return this.prev;
+    getPrev<T extends CircleListNode> () {
+        return this.prev as T;
     }
 
-    setPrev (node: CircleListNode<T>) {
+    setPrev (node: CircleListNode) {
         this.prev = node;
     }
 
@@ -42,31 +34,27 @@ export class CircleListNode<T> {
     }
 }
 
-export class CircleList<T> {
-    private readonly list: Array<CircleListNode<T>>;
+export class CircleList<T extends CircleListNode> {
+    private readonly list: Array<T>;
 
     constructor () {
         this.list = [];
     }
 
-    get (index: number): CircleListNode<T> | undefined {
+    get (index: number): T | undefined {
         return this.list[index];
     }
 
-    getData (index: number) {
-        return this.get(index)?.getData();
-    }
-
     getNextChain (first: number): Array<T> {
         const chain: Array<T> = [];
         let firstNode = this.list[first];
-        let nextNode = firstNode.getNext();
+        let nextNode = firstNode.getNext<T>();
 
-        chain.push(firstNode.getData());
+        chain.push(firstNode);
 
         while (firstNode !== nextNode && nextNode) {
-            chain.push(nextNode.getData());
-            nextNode = nextNode.getNext();
+            chain.push(nextNode);
+            nextNode = nextNode.getNext<T>();
         }
 
         return chain;
@@ -75,13 +63,13 @@ export class CircleList<T> {
     getPrevChain (first: number): Array<T> {
         const chain: Array<T> = [];
         let firstNode = this.list[first];
-        let prevNode = firstNode.getPrev();
+        let prevNode = firstNode.getPrev<T>();
 
-        chain.push(firstNode.getData());
+        chain.push(firstNode);
 
         while (firstNode !== prevNode && prevNode) {
-            chain.push(prevNode.getData());
-            prevNode = prevNode.getPrev();
+            chain.push(prevNode);
+            prevNode = prevNode.getPrev<T>();
         }
 
         return chain;
@@ -92,16 +80,16 @@ export class CircleList<T> {
     }
 
     getSlice (start: number, end?: number): Array<T> {
-        return slice(this.list, start, end).map((item) => item.getData());
+        return slice(this.list, start, end).map((item) => item);
     }
 
-    push (data: T) {
-        this.list.push(new CircleListNode(data));
+    push (node: T) {
+        this.list.push(node);
         this.connect();
     }
 
     toArray (): Array<T> {
-        return this.list.map((item) => item.getData());
+        return this.list.map((item) => item);
     }
 
     private connect () {