Update tests to match new implementations

__tests__/managers/ConnectionManager.test.js

     .mockImplementationOnce(() => {
       return Promise.resolve(true);
     });
-  return expect(c.connect('email', 'password')).resolves.toBeTruthy();
+  return expect(c.connect('email', 'password')).resolves.toBe(undefined);
 });
 
 test('connect good credentials no consent', () => {
       return Promise.reject(false);
     });
   return expect(c.connect('email', 'password')).rejects.toBe(
-    ERROR_TYPE.UNKNOWN,
+    ERROR_TYPE.TOKEN_SAVE,
   );
 });
 
     });
   });
   return expect(c.connect('email', 'password')).rejects.toBe(
-    ERROR_TYPE.CONNECTION_ERROR,
+    ERROR_TYPE.SERVER_ERROR,
   );
 });
 
   });
   return expect(
     c.authenticatedRequest('https://www.amicale-insat.fr/api/token/check'),
-  ).rejects.toBe(ERROR_TYPE.CONNECTION_ERROR);
+  ).rejects.toBe(ERROR_TYPE.SERVER_ERROR);
 });
 
 test('authenticatedRequest connection error', () => {
     });
   return expect(
     c.authenticatedRequest('https://www.amicale-insat.fr/api/token/check'),
-  ).rejects.toBe(ERROR_TYPE.UNKNOWN);
+  ).rejects.toBe(ERROR_TYPE.TOKEN_RETRIEVE);
 });

src/screens/Game/__tests__/GridManager.test.js

 import ScoreManager from '../logic/ScoreManager';
 import Piece from '../logic/Piece';
 
-let colors = {
-  tetrisBackground: '#000002',
+let theme = {
+  colors: {
+    tetrisBackground: '#000002',
+  },
 };
 
-jest.mock('../ScoreManager');
+jest.mock('../logic/ScoreManager');
 
 afterAll(() => {
   jest.restoreAllMocks();
 });
 
 test('getEmptyLine', () => {
-  let g = new GridManager(2, 2, colors);
+  let g = new GridManager(2, 2, theme);
   expect(g.getEmptyLine(2)).toStrictEqual([
-    {color: colors.tetrisBackground, isEmpty: true},
-    {color: colors.tetrisBackground, isEmpty: true},
+    {color: theme.colors.tetrisBackground, isEmpty: true, key: '0'},
+    {color: theme.colors.tetrisBackground, isEmpty: true, key: '1'},
   ]);
 
   expect(g.getEmptyLine(-1)).toStrictEqual([]);
 });
 
 test('getEmptyGrid', () => {
-  let g = new GridManager(2, 2, colors);
+  let g = new GridManager(2, 2, theme);
   expect(g.getEmptyGrid(2, 2)).toStrictEqual([
     [
-      {color: colors.tetrisBackground, isEmpty: true},
-      {color: colors.tetrisBackground, isEmpty: true},
+      {color: theme.colors.tetrisBackground, isEmpty: true, key: '0'},
+      {color: theme.colors.tetrisBackground, isEmpty: true, key: '1'},
     ],
     [
-      {color: colors.tetrisBackground, isEmpty: true},
-      {color: colors.tetrisBackground, isEmpty: true},
+      {color: theme.colors.tetrisBackground, isEmpty: true, key: '0'},
+      {color: theme.colors.tetrisBackground, isEmpty: true, key: '1'},
     ],
   ]);
 
 });
 
 test('getLinesToClear', () => {
-  let g = new GridManager(2, 2, colors);
+  let g = new GridManager(2, 2, theme);
   g.getCurrentGrid()[0][0].isEmpty = false;
   g.getCurrentGrid()[0][1].isEmpty = false;
   let coord = [{x: 1, y: 0}];
 });
 
 test('clearLines', () => {
-  let g = new GridManager(2, 2, colors);
+  let g = new GridManager(2, 2, theme);
   let grid = [
     [
-      {color: colors.tetrisBackground, isEmpty: true},
-      {color: colors.tetrisBackground, isEmpty: true},
+      {color: theme.colors.tetrisBackground, isEmpty: true, key: '0'},
+      {color: theme.colors.tetrisBackground, isEmpty: true, key: '1'},
     ],
     [
-      {color: '0', isEmpty: true},
-      {color: '0', isEmpty: true},
+      {color: '0', isEmpty: true, key: '0'},
+      {color: '0', isEmpty: true, key: '1'},
     ],
   ];
   g.getCurrentGrid()[1][0].color = '0';
   g.clearLines([1], scoreManager);
   grid = [
     [
-      {color: colors.tetrisBackground, isEmpty: true},
-      {color: colors.tetrisBackground, isEmpty: true},
+      {color: theme.colors.tetrisBackground, isEmpty: true, key: '0'},
+      {color: theme.colors.tetrisBackground, isEmpty: true, key: '1'},
     ],
     [
-      {color: colors.tetrisBackground, isEmpty: true},
-      {color: colors.tetrisBackground, isEmpty: true},
+      {color: theme.colors.tetrisBackground, isEmpty: true, key: '0'},
+      {color: theme.colors.tetrisBackground, isEmpty: true, key: '1'},
     ],
   ];
   expect(g.getCurrentGrid()).toStrictEqual(grid);
 });
 
 test('freezeTetromino', () => {
-  let g = new GridManager(2, 2, colors);
+  let g = new GridManager(2, 2, theme);
   let spy1 = jest
     .spyOn(GridManager.prototype, 'getLinesToClear')
     .mockImplementation(() => {});

src/screens/Game/__tests__/Piece.test.js

 import Piece from '../logic/Piece';
 import ShapeI from '../Shapes/ShapeI';
 
-let colors = {
-  tetrisI: '#000001',
-  tetrisBackground: '#000002',
+let theme = {
+  colors: {
+    tetrisI: '#000001',
+    tetrisBackground: '#000002',
+  },
 };
 
 jest.mock('../Shapes/ShapeI');
   ];
   let size = 2;
 
-  let p = new Piece(colors);
+  let p = new Piece(theme);
   expect(p.isPositionValid(grid, size, size)).toBeTrue();
   x = 1;
   y = 0;
 });
 
 test('tryMove', () => {
-  let p = new Piece(colors);
+  let p = new Piece(theme);
   const callbackMock = jest.fn();
   let isValid = true;
   let spy1 = jest
 });
 
 test('tryRotate', () => {
-  let p = new Piece(colors);
+  let p = new Piece(theme);
   let isValid = true;
   let spy1 = jest
     .spyOn(Piece.prototype, 'isPositionValid')
       return [{x: x, y: y}];
     });
   let spy2 = jest.spyOn(ShapeI.prototype, 'getColor').mockImplementation(() => {
-    return colors.tetrisI;
+    return theme.colors.tetrisI;
   });
   let grid = [
-    [{isEmpty: true}, {isEmpty: true}],
-    [{isEmpty: true}, {isEmpty: true}],
+    [
+      {isEmpty: true, key: '0'},
+      {isEmpty: true, key: '1'},
+    ],
+    [
+      {isEmpty: true, key: '0'},
+      {isEmpty: true, key: '1'},
+    ],
   ];
   let expectedGrid = [
-    [{color: colors.tetrisI, isEmpty: false}, {isEmpty: true}],
-    [{isEmpty: true}, {isEmpty: true}],
+    [
+      {color: theme.colors.tetrisI, isEmpty: false, key: '0'},
+      {isEmpty: true, key: '1'},
+    ],
+    [
+      {isEmpty: true, key: '0'},
+      {isEmpty: true, key: '1'},
+    ],
   ];
 
-  let p = new Piece(colors);
+  let p = new Piece(theme);
   p.toGrid(grid, true);
   expect(grid).toStrictEqual(expectedGrid);
 
 test('removeFromGrid', () => {
   let gridOld = [
     [
-      {color: colors.tetrisI, isEmpty: false},
-      {color: colors.tetrisI, isEmpty: false},
-      {color: colors.tetrisBackground, isEmpty: true},
+      {color: theme.colors.tetrisI, isEmpty: false, key: '0'},
+      {color: theme.colors.tetrisI, isEmpty: false, key: '1'},
+      {color: theme.colors.tetrisBackground, isEmpty: true, key: '2'},
     ],
   ];
   let gridNew = [
     [
-      {color: colors.tetrisBackground, isEmpty: true},
-      {color: colors.tetrisBackground, isEmpty: true},
-      {color: colors.tetrisBackground, isEmpty: true},
+      {color: theme.colors.tetrisBackground, isEmpty: true, key: '0'},
+      {color: theme.colors.tetrisBackground, isEmpty: true, key: '1'},
+      {color: theme.colors.tetrisBackground, isEmpty: true, key: '2'},
     ],
   ];
   let oldCoord = [
       return oldCoord;
     });
   let spy2 = jest.spyOn(ShapeI.prototype, 'getColor').mockImplementation(() => {
-    return colors.tetrisI;
+    return theme.colors.tetrisI;
   });
-  let p = new Piece(colors);
+  let p = new Piece(theme);
   p.removeFromGrid(gridOld);
   expect(gridOld).toStrictEqual(gridNew);
 

src/screens/Game/__tests__/Shape.test.js

 import BaseShape from '../Shapes/BaseShape';
 import ShapeI from '../Shapes/ShapeI';
 
-const colors = {
-  tetrisI: '#000001',
-  tetrisO: '#000002',
-  tetrisT: '#000003',
-  tetrisS: '#000004',
-  tetrisZ: '#000005',
-  tetrisJ: '#000006',
-  tetrisL: '#000007',
+const theme = {
+  colors: {
+    tetrisI: '#000001',
+    tetrisO: '#000002',
+    tetrisT: '#000003',
+    tetrisS: '#000004',
+    tetrisZ: '#000005',
+    tetrisJ: '#000006',
+    tetrisL: '#000007',
+  },
 };
 
 test('constructor', () => {
   expect(() => new BaseShape()).toThrow(Error);
 
-  let T = new ShapeI(colors);
+  let T = new ShapeI(theme);
   expect(T.position.y).toBe(0);
   expect(T.position.x).toBe(3);
   expect(T.getCurrentShape()).toStrictEqual(T.getShapes()[0]);
-  expect(T.getColor()).toBe(colors.tetrisI);
+  expect(T.getColor()).toBe(theme.colors.tetrisI);
 });
 
 test('move', () => {
-  let T = new ShapeI(colors);
+  let T = new ShapeI(theme);
   T.move(0, 1);
   expect(T.position.x).toBe(3);
   expect(T.position.y).toBe(1);
 });
 
 test('rotate', () => {
-  let T = new ShapeI(colors);
+  let T = new ShapeI(theme);
   T.rotate(true);
   expect(T.getCurrentShape()).toStrictEqual(T.getShapes()[1]);
   T.rotate(true);
 });
 
 test('getCellsCoordinates', () => {
-  let T = new ShapeI(colors);
+  let T = new ShapeI(theme);
   expect(T.getCellsCoordinates(false)).toStrictEqual([
     {x: 0, y: 1},
     {x: 1, y: 1},