Skip to content

Commit 12f6f49

Browse files
author
Jaissica Hora
committed
test: added tests for getVersion, use, terminate method in roktManager
1 parent e3cb599 commit 12f6f49

2 files changed

Lines changed: 284 additions & 1 deletion

File tree

‎src/roktManager.ts‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -287,7 +287,7 @@ export default class RoktManager {
287287
}
288288

289289
try {
290-
return this.kit.launcher.getVersion();
290+
return this.kit.getVersion();
291291
} catch (error) {
292292
return Promise.reject(error instanceof Error ? error : new Error('Error getting the version'));
293293
}

‎test/jest/roktManager.spec.ts‎

Lines changed: 283 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1214,6 +1214,289 @@ describe('RoktManager', () => {
12141214
});
12151215
});
12161216

1217+
describe('#terminate', () => {
1218+
it('should call kit.terminate when already attached', async () => {
1219+
const kit: IRoktKit = {
1220+
launcher: {
1221+
selectPlacements: jest.fn(),
1222+
hashAttributes: jest.fn(),
1223+
use: jest.fn(),
1224+
getVersion: jest.fn(),
1225+
terminate: jest.fn(),
1226+
},
1227+
filters: undefined,
1228+
filteredUser: undefined,
1229+
userAttributes: undefined,
1230+
selectPlacements: jest.fn(),
1231+
hashAttributes: jest.fn(),
1232+
setExtensionData: jest.fn(),
1233+
use: jest.fn(),
1234+
getVersion: jest.fn(),
1235+
terminate: jest.fn(),
1236+
};
1237+
1238+
roktManager.attachKit(kit);
1239+
1240+
roktManager.terminate();
1241+
expect(kit.terminate).toHaveBeenCalled();
1242+
});
1243+
1244+
it('should queue the terminate method if no launcher or kit is attached', () => {
1245+
roktManager.terminate();
1246+
1247+
expect(roktManager['kit']).toBeNull();
1248+
expect(roktManager['messageQueue'].size).toBe(1);
1249+
const queuedMessage = Array.from(roktManager['messageQueue'].values())[0];
1250+
expect(queuedMessage.methodName).toBe('terminate');
1251+
expect(queuedMessage.payload).toEqual({});
1252+
});
1253+
1254+
it('should process queued terminate once the launcher and kit are attached', async () => {
1255+
const kit: IRoktKit = {
1256+
launcher: {
1257+
selectPlacements: jest.fn(),
1258+
hashAttributes: jest.fn(),
1259+
use: jest.fn(),
1260+
getVersion: jest.fn(),
1261+
terminate: jest.fn(),
1262+
},
1263+
filters: undefined,
1264+
filteredUser: undefined,
1265+
userAttributes: undefined,
1266+
selectPlacements: jest.fn(),
1267+
hashAttributes: jest.fn(),
1268+
setExtensionData: jest.fn(),
1269+
use: jest.fn(),
1270+
getVersion: jest.fn(),
1271+
terminate: jest.fn(),
1272+
};
1273+
1274+
roktManager.terminate();
1275+
1276+
expect(roktManager['kit']).toBeNull();
1277+
expect(roktManager['messageQueue'].size).toBe(1);
1278+
const queuedMessage = Array.from(roktManager['messageQueue'].values())[0];
1279+
expect(queuedMessage.methodName).toBe('terminate');
1280+
expect(queuedMessage.payload).toEqual({});
1281+
1282+
roktManager.attachKit(kit);
1283+
expect(roktManager['kit']).not.toBeNull();
1284+
expect(roktManager['messageQueue'].size).toBe(0);
1285+
expect(kit.terminate).toHaveBeenCalled();
1286+
});
1287+
1288+
it('should pass through to kit.launcher.terminate', async () => {
1289+
const kit: Partial<IRoktKit> = {
1290+
launcher: {
1291+
selectPlacements: jest.fn(),
1292+
hashAttributes: jest.fn(),
1293+
use: jest.fn(),
1294+
getVersion: jest.fn(),
1295+
terminate: jest.fn(),
1296+
},
1297+
terminate: jest.fn().mockImplementation(() => (kit.launcher).terminate()),
1298+
};
1299+
1300+
roktManager.attachKit(kit as IRoktKit);
1301+
1302+
roktManager.terminate();
1303+
expect(kit.terminate).toHaveBeenCalled();
1304+
expect(kit.launcher.terminate).toHaveBeenCalled();
1305+
});
1306+
});
1307+
1308+
describe('#getVersion', () => {
1309+
it('should call kit.getVersion', async () => {
1310+
const kit: IRoktKit = {
1311+
launcher: {
1312+
selectPlacements: jest.fn(),
1313+
hashAttributes: jest.fn(),
1314+
use: jest.fn(),
1315+
getVersion: jest.fn().mockResolvedValue('1.1'),
1316+
terminate: jest.fn(),
1317+
},
1318+
getVersion: jest.fn().mockImplementation(() => kit.launcher.getVersion()),
1319+
filters: undefined,
1320+
filteredUser: undefined,
1321+
userAttributes: undefined,
1322+
hashAttributes: jest.fn(),
1323+
selectPlacements: jest.fn(),
1324+
setExtensionData: jest.fn(),
1325+
use: jest.fn(),
1326+
terminate: jest.fn(),
1327+
};
1328+
1329+
roktManager.attachKit(kit);
1330+
1331+
const version = await roktManager.getVersion();
1332+
expect(kit.getVersion).toHaveBeenCalled();
1333+
expect(version).toBe('1.1');
1334+
});
1335+
1336+
it('should queue the getVersion method if no launcher or kit is attached', () => {
1337+
roktManager.getVersion();
1338+
1339+
expect(roktManager['kit']).toBeNull();
1340+
expect(roktManager['messageQueue'].size).toBe(1);
1341+
const queuedMessage = Array.from(roktManager['messageQueue'].values())[0];
1342+
expect(queuedMessage.methodName).toBe('getVersion');
1343+
expect(queuedMessage.payload).toEqual({});
1344+
});
1345+
1346+
it('should process queued getVersion calls once the launcher and kit are attached', () => {
1347+
const kit: IRoktKit = {
1348+
launcher: {
1349+
selectPlacements: jest.fn(),
1350+
hashAttributes: jest.fn(),
1351+
use: jest.fn(),
1352+
getVersion: jest.fn(),
1353+
terminate: jest.fn(),
1354+
},
1355+
selectPlacements: jest.fn(),
1356+
hashAttributes: jest.fn(),
1357+
setExtensionData: jest.fn(),
1358+
use: jest.fn(),
1359+
terminate: jest.fn(),
1360+
getVersion: jest.fn(),
1361+
filters: undefined,
1362+
filteredUser: undefined,
1363+
userAttributes: undefined,
1364+
};
1365+
1366+
roktManager.getVersion();
1367+
1368+
expect(roktManager['kit']).toBeNull();
1369+
expect(roktManager['messageQueue'].size).toBe(1);
1370+
const queuedMessage = Array.from(roktManager['messageQueue'].values())[0];
1371+
expect(queuedMessage.methodName).toBe('getVersion');
1372+
expect(queuedMessage.payload).toEqual({});
1373+
1374+
roktManager.attachKit(kit);
1375+
expect(roktManager['kit']).not.toBeNull();
1376+
expect(roktManager['messageQueue'].size).toBe(0);
1377+
expect(kit.getVersion).toHaveBeenCalled();
1378+
});
1379+
1380+
it('should pass through to kit.launcher.getVersion and return the version', async () => {
1381+
const kit: Partial<IRoktKit> = {
1382+
launcher: {
1383+
selectPlacements: jest.fn(),
1384+
hashAttributes: jest.fn(),
1385+
use: jest.fn(),
1386+
getVersion: jest.fn().mockResolvedValue('1.1'),
1387+
terminate: jest.fn(),
1388+
},
1389+
getVersion: jest.fn().mockImplementation(() => (kit.launcher).getVersion()),
1390+
};
1391+
1392+
roktManager.attachKit(kit as IRoktKit);
1393+
1394+
const version = await roktManager.getVersion();
1395+
expect(kit.getVersion).toHaveBeenCalled();
1396+
expect(kit.launcher.getVersion).toHaveBeenCalled();
1397+
expect(version).toBe('1.1');
1398+
});
1399+
});
1400+
1401+
describe('#use', () => {
1402+
it('should call kit.use with provided name', async () => {
1403+
const kit: IRoktKit = {
1404+
launcher: {
1405+
selectPlacements: jest.fn(),
1406+
hashAttributes: jest.fn(),
1407+
use: jest.fn(),
1408+
getVersion: jest.fn(),
1409+
terminate: jest.fn(),
1410+
},
1411+
filters: undefined,
1412+
filteredUser: undefined,
1413+
userAttributes: undefined,
1414+
selectPlacements: jest.fn(),
1415+
hashAttributes: jest.fn(),
1416+
setExtensionData: jest.fn(),
1417+
use: jest.fn(),
1418+
getVersion: jest.fn(),
1419+
terminate: jest.fn(),
1420+
};
1421+
1422+
roktManager.attachKit(kit);
1423+
1424+
roktManager.use('ThankYouPageJourney');
1425+
expect(kit.use).toHaveBeenCalledWith('ThankYouPageJourney');
1426+
});
1427+
1428+
it('should queue the use method if no launcher or kit is attached', () => {
1429+
roktManager.use('ThankYouPageJourney');
1430+
1431+
expect(roktManager['kit']).toBeNull();
1432+
expect(roktManager['messageQueue'].size).toBe(1);
1433+
const queuedMessage = Array.from(roktManager['messageQueue'].values())[0];
1434+
expect(queuedMessage.methodName).toBe('use');
1435+
expect(queuedMessage.payload).toBe('ThankYouPageJourney');
1436+
});
1437+
1438+
it('should process queued use calls once the launcher and kit are attached', async () => {
1439+
const kit: IRoktKit = {
1440+
launcher: {
1441+
selectPlacements: jest.fn(),
1442+
hashAttributes: jest.fn(),
1443+
use: jest.fn(),
1444+
getVersion: jest.fn(),
1445+
terminate: jest.fn(),
1446+
},
1447+
filters: undefined,
1448+
filteredUser: undefined,
1449+
userAttributes: undefined,
1450+
selectPlacements: jest.fn(),
1451+
hashAttributes: jest.fn(),
1452+
setExtensionData: jest.fn(),
1453+
use: jest.fn(),
1454+
getVersion: jest.fn(),
1455+
terminate: jest.fn(),
1456+
};
1457+
1458+
roktManager.use('ThankYouPageJourney');
1459+
1460+
expect(roktManager['kit']).toBeNull();
1461+
expect(roktManager['messageQueue'].size).toBe(1);
1462+
const queuedMessage = Array.from(roktManager['messageQueue'].values())[0];
1463+
expect(queuedMessage.methodName).toBe('use');
1464+
expect(queuedMessage.payload).toBe('ThankYouPageJourney');
1465+
expect(kit.use).not.toHaveBeenCalled();
1466+
1467+
roktManager.attachKit(kit);
1468+
1469+
expect(roktManager['messageQueue'].size).toBe(0);
1470+
expect(roktManager['kit']).not.toBeNull();
1471+
expect(kit.use).toHaveBeenCalledWith('ThankYouPageJourney');
1472+
});
1473+
1474+
it('should pass through to kit.launcher.use and return the value', async () => {
1475+
const kit: Partial<IRoktKit> = {
1476+
launcher: {
1477+
selectPlacements: jest.fn(),
1478+
hashAttributes: jest.fn(),
1479+
use: jest.fn().mockResolvedValue('test-use'),
1480+
getVersion: jest.fn(),
1481+
terminate: jest.fn(),
1482+
},
1483+
selectPlacements: jest.fn(),
1484+
hashAttributes: jest.fn(),
1485+
setExtensionData: jest.fn(),
1486+
use: jest.fn().mockImplementation((name: string) => (kit.launcher).use(name)),
1487+
getVersion: jest.fn(),
1488+
terminate: jest.fn(),
1489+
};
1490+
1491+
roktManager.attachKit(kit as IRoktKit);
1492+
1493+
const result = await roktManager.use<string>('ThankYouPageJourney');
1494+
expect(kit.use).toHaveBeenCalledWith('ThankYouPageJourney');
1495+
expect(kit.launcher.use).toHaveBeenCalledWith('ThankYouPageJourney');
1496+
expect(result).toBe('test-use');
1497+
});
1498+
});
1499+
12171500
describe('#deferredCall', () => {
12181501
it('should create a deferred promise with unique messageId', () => {
12191502
const testPayload = { test: 'data' };

0 commit comments

Comments
 (0)